{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/huang/sympy_work_code/2024'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load \"./environment.py\"\n",
    "# the jupyter ServerApp's dir_direction is %pwd.\n",
    "\n",
    "from sympy.abc import x,y,z,t,k,l,n,m,p,q\n",
    "from sympy import *\n",
    "from sympy.calculus.util import *\n",
    "from sympy.stats import *\n",
    "\n",
    "from sys import path,platform\n",
    "match platform:\n",
    "    case \"linux\":\n",
    "            path.append(\"/home/huang/Documents/packaging_tutorial/src\")\n",
    "    case \"darwin\":\n",
    "        path.append(\"/Users/huangzhiming/Documents/python学习/packaging_tutorial/src\")\n",
    "%load_ext autoreload \n",
    "%autoreload 1\n",
    "\n",
    "%aimport basic_package.utils\n",
    "%aimport function_calculator_package.extreme_points\n",
    "%aimport function_calculator_package.utils\n",
    "%aimport quadratic_function.utils\n",
    "%aimport quadratic_function.hyperbola\n",
    "%aimport quadratic_function.utils\n",
    "\n",
    "from basic_package.utils import *\n",
    "from function_calculator_package.extreme_points import *\n",
    "from function_calculator_package.utils import *\n",
    "from quadratic_function.quadraticfunction import QuadraticFunction\n",
    "from quadratic_function.hyperbola import Hyperbola\n",
    "from quadratic_function.utils import line_and_quadratic\n",
    "\n",
    "%aimport excel_function_package.chi_square_test\n",
    "from excel_function_package.chi_square_test import ChiSquaredTest,chi_squared_of_error_probability\n",
    "%aimport excel_function_package.data\n",
    "\n",
    "from excel_function_package.data import Data\n",
    "\n",
    "%aimport solver.utils\n",
    "from solver.utils import solve_univariate_inequalities\n",
    "\n",
    "%aimport function_calculator_package.utils \n",
    "from function_calculator_package.utils import function_is_odd,function_is_even\n",
    "\n",
    "%aimport geometry3D.frustum\n",
    "%aimport geometry3D.prism\n",
    "%aimport geometry3D.pyramid\n",
    "%aimport geometry3D.frustum_cone\n",
    "%aimport geometry3D.sphere\n",
    "\n",
    "from geometry3D.frustum import Frustum\n",
    "from geometry3D.prism import Prism,Cube\n",
    "from geometry3D.pyramid import Pyramid,Cone,Tetrahedron\n",
    "from geometry3D.frustum_cone import FrustumCone\n",
    "from geometry3D.sphere import Sphere\n",
    "a,b,c=symbols(\"a,b,c\",real=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 顶尖试卷大题"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=solveset(x**2-2*x>0,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, 0\\right) \\cup \\left(2, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(-oo, 0), Interval.open(2, oo))"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=continuous_domain(log(Abs(x),2),x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, 0\\right) \\cup \\left(0, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(-oo, 0), Interval.open(0, oo))"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(0, 2\\right]$"
      ],
      "text/plain": [
       "Interval.Lopen(0, 2)"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(Reals-A)&B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "z=(2-I)*(1+2*I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(1 + 2 i\\right) \\left(2 - i\\right)$"
      ],
      "text/plain": [
       "(1 + 2*I)*(2 - I)"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{17}$"
      ],
      "text/plain": [
       "sqrt(17)"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Abs(conjugate(z)+2*I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "an_seq=sequence(a*q**(n-1),(n,1,8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[a, a q, a q^{2}, a q^{3}, \\ldots\\right]$"
      ],
      "text/plain": [
       "SeqFormula(a*q**(n - 1), (n, 1, 8))"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "an_seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - a q^{2} + 6 a - 1$"
      ],
      "text/plain": [
       "-a*q**2 + 6*a - 1"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6*an_seq[0]-an_seq[2]-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( - \\frac{1}{3}, \\  -3\\right), \\left( \\frac{1}{2}, \\  2\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(-1/3, -3), (1/2, 2)}"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nonlinsolve([_,a*q-1],[a,q],Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 28$"
      ],
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(an_seq[3:6]).subs({a:1/S(2),q:2})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b=symbols(\"a,b\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [],
   "source": [
    "hyper=Hyperbola(Point(0,0),a,b,slope=oo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -1 - \\frac{x^{2}}{b^{2}} + \\frac{y^{2}}{a^{2}}$"
      ],
      "text/plain": [
       "-1 - x**2/b**2 + y**2/a**2"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hyper.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [],
   "source": [
    "F2,F1=hyper.foci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(0, \\sqrt{a^{2} + b^{2}}\\right)$"
      ],
      "text/plain": [
       "Point2D(0, sqrt(a**2 + b**2))"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "para=Parabola(F1,Line(F2,slope=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - x^{2} + 4 y \\sqrt{a^{2} + b^{2}}$"
      ],
      "text/plain": [
       "-x**2 + 4*y*sqrt(a**2 + b**2)"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(para.equation())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( - 2 \\sqrt[4]{a^{2} + b^{2}} \\sqrt{\\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} - \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}}, \\  \\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} - \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}\\right), \\left( 2 \\sqrt[4]{a^{2} + b^{2}} \\sqrt{\\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} - \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}}, \\  \\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} - \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}\\right), \\left( - 2 \\sqrt[4]{a^{2} + b^{2}} \\sqrt{\\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} + \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}}, \\  \\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} + \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}\\right), \\left( 2 \\sqrt[4]{a^{2} + b^{2}} \\sqrt{\\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} + \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}}, \\  \\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} + \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(-2*(a**2 + b**2)**(1/4)*sqrt(2*a**2*sqrt(a**2 + b**2)/b**2 - a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2), 2*a**2*sqrt(a**2 + b**2)/b**2 - a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2), (2*(a**2 + b**2)**(1/4)*sqrt(2*a**2*sqrt(a**2 + b**2)/b**2 - a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2), 2*a**2*sqrt(a**2 + b**2)/b**2 - a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2), (-2*(a**2 + b**2)**(1/4)*sqrt(2*a**2*sqrt(a**2 + b**2)/b**2 + a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2), 2*a**2*sqrt(a**2 + b**2)/b**2 + a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2), (2*(a**2 + b**2)**(1/4)*sqrt(2*a**2*sqrt(a**2 + b**2)/b**2 + a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2), 2*a**2*sqrt(a**2 + b**2)/b**2 + a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2)}"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nonlinsolve([para.equation(x,y),hyper.equation(x,y)],[x,y],Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [],
   "source": [
    "anwers=list(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(anwers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=anwers[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( - 2 \\sqrt[4]{a^{2} + b^{2}} \\sqrt{\\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} + \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}}, \\  \\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} + \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}\\right)$"
      ],
      "text/plain": [
       "(-2*(a**2 + b**2)**(1/4)*sqrt(2*a**2*sqrt(a**2 + b**2)/b**2 + a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2), 2*a**2*sqrt(a**2 + b**2)/b**2 + a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2)"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "M=Point(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(- 2 \\sqrt[4]{a^{2} + b^{2}} \\sqrt{\\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} + \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}}, \\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} + \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}\\right)$"
      ],
      "text/plain": [
       "Point2D(-2*(a**2 + b**2)**(1/4)*sqrt(2*a**2*sqrt(a**2 + b**2)/b**2 + a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2), 2*a**2*sqrt(a**2 + b**2)/b**2 + a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2)"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 4 a^{2} - 4 b^{2} + 4 \\sqrt{a^{2} + b^{2}} \\cdot \\left(\\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} + \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}}\\right) + \\left(\\frac{2 a^{2} \\sqrt{a^{2} + b^{2}}}{b^{2}} + \\frac{a \\sqrt{4 a^{2} \\left(a^{2} + b^{2}\\right) + b^{4}}}{b^{2}} - \\sqrt{a^{2} + b^{2}}\\right)^{2}$"
      ],
      "text/plain": [
       "-4*a**2 - 4*b**2 + 4*sqrt(a**2 + b**2)*(2*a**2*sqrt(a**2 + b**2)/b**2 + a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2) + (2*a**2*sqrt(a**2 + b**2)/b**2 + a*sqrt(4*a**2*(a**2 + b**2) + b**4)/b**2 - sqrt(a**2 + b**2))**2"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(M.distance(F1))**2-(F2.distance(F1))**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(\\mathbb{R} \\cap \\left\\{- a \\sqrt{- \\frac{10}{9} - \\frac{2 \\sqrt{2} i}{9}}, a \\sqrt{- \\frac{10}{9} - \\frac{2 \\sqrt{2} i}{9}}, - a \\sqrt{- \\frac{10}{9} + \\frac{2 \\sqrt{2} i}{9}}, a \\sqrt{- \\frac{10}{9} + \\frac{2 \\sqrt{2} i}{9}}, - a \\sqrt{2 + 2 \\sqrt{2}}, a \\sqrt{2 + 2 \\sqrt{2}}\\right\\}\\right) \\setminus \\left\\{0\\right\\}$"
      ],
      "text/plain": [
       "Complement(Intersection({-a*sqrt(-10/9 - 2*sqrt(2)*I/9), a*sqrt(-10/9 - 2*sqrt(2)*I/9), -a*sqrt(-10/9 + 2*sqrt(2)*I/9), a*sqrt(-10/9 + 2*sqrt(2)*I/9), -a*sqrt(2 + 2*sqrt(2)), a*sqrt(2 + 2*sqrt(2))}, Reals), {0})"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(simplify(_),b,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1 + \\sqrt{2}$"
      ],
      "text/plain": [
       "1 + sqrt(2)"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nsimplify(sqrt(3+2*sqrt(2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function plot in module sympy.plotting.plot:\n",
      "\n",
      "plot(*args, show=True, **kwargs)\n",
      "    Plots a function of a single variable as a curve.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    args :\n",
      "        The first argument is the expression representing the function\n",
      "        of single variable to be plotted.\n",
      "    \n",
      "        The last argument is a 3-tuple denoting the range of the free\n",
      "        variable. e.g. ``(x, 0, 5)``\n",
      "    \n",
      "        Typical usage examples are in the followings:\n",
      "    \n",
      "        - Plotting a single expression with a single range.\n",
      "            ``plot(expr, range, **kwargs)``\n",
      "        - Plotting a single expression with the default range (-10, 10).\n",
      "            ``plot(expr, **kwargs)``\n",
      "        - Plotting multiple expressions with a single range.\n",
      "            ``plot(expr1, expr2, ..., range, **kwargs)``\n",
      "        - Plotting multiple expressions with multiple ranges.\n",
      "            ``plot((expr1, range1), (expr2, range2), ..., **kwargs)``\n",
      "    \n",
      "        It is best practice to specify range explicitly because default\n",
      "        range may change in the future if a more advanced default range\n",
      "        detection algorithm is implemented.\n",
      "    \n",
      "    show : bool, optional\n",
      "        The default value is set to ``True``. Set show to ``False`` and\n",
      "        the function will not display the plot. The returned instance of\n",
      "        the ``Plot`` class can then be used to save or display the plot\n",
      "        by calling the ``save()`` and ``show()`` methods respectively.\n",
      "    \n",
      "    line_color : string, or float, or function, optional\n",
      "        Specifies the color for the plot.\n",
      "        See ``Plot`` to see how to set color for the plots.\n",
      "        Note that by setting ``line_color``, it would be applied simultaneously\n",
      "        to all the series.\n",
      "    \n",
      "    title : str, optional\n",
      "        Title of the plot. It is set to the latex representation of\n",
      "        the expression, if the plot has only one expression.\n",
      "    \n",
      "    label : str, optional\n",
      "        The label of the expression in the plot. It will be used when\n",
      "        called with ``legend``. Default is the name of the expression.\n",
      "        e.g. ``sin(x)``\n",
      "    \n",
      "    xlabel : str or expression, optional\n",
      "        Label for the x-axis.\n",
      "    \n",
      "    ylabel : str or expression, optional\n",
      "        Label for the y-axis.\n",
      "    \n",
      "    xscale : 'linear' or 'log', optional\n",
      "        Sets the scaling of the x-axis.\n",
      "    \n",
      "    yscale : 'linear' or 'log', optional\n",
      "        Sets the scaling of the y-axis.\n",
      "    \n",
      "    axis_center : (float, float), optional\n",
      "        Tuple of two floats denoting the coordinates of the center or\n",
      "        {'center', 'auto'}\n",
      "    \n",
      "    xlim : (float, float), optional\n",
      "        Denotes the x-axis limits, ``(min, max)```.\n",
      "    \n",
      "    ylim : (float, float), optional\n",
      "        Denotes the y-axis limits, ``(min, max)```.\n",
      "    \n",
      "    annotations : list, optional\n",
      "        A list of dictionaries specifying the type of annotation\n",
      "        required. The keys in the dictionary should be equivalent\n",
      "        to the arguments of the :external:mod:`matplotlib`'s\n",
      "        :external:meth:`~matplotlib.axes.Axes.annotate` method.\n",
      "    \n",
      "    markers : list, optional\n",
      "        A list of dictionaries specifying the type the markers required.\n",
      "        The keys in the dictionary should be equivalent to the arguments\n",
      "        of the :external:mod:`matplotlib`'s :external:func:`~matplotlib.pyplot.plot()` function\n",
      "        along with the marker related keyworded arguments.\n",
      "    \n",
      "    rectangles : list, optional\n",
      "        A list of dictionaries specifying the dimensions of the\n",
      "        rectangles to be plotted. The keys in the dictionary should be\n",
      "        equivalent to the arguments of the :external:mod:`matplotlib`'s\n",
      "        :external:class:`~matplotlib.patches.Rectangle` class.\n",
      "    \n",
      "    fill : dict, optional\n",
      "        A dictionary specifying the type of color filling required in\n",
      "        the plot. The keys in the dictionary should be equivalent to the\n",
      "        arguments of the :external:mod:`matplotlib`'s\n",
      "        :external:meth:`~matplotlib.axes.Axes.fill_between` method.\n",
      "    \n",
      "    adaptive : bool, optional\n",
      "        The default value is set to ``True``. Set adaptive to ``False``\n",
      "        and specify ``nb_of_points`` if uniform sampling is required.\n",
      "    \n",
      "        The plotting uses an adaptive algorithm which samples\n",
      "        recursively to accurately plot. The adaptive algorithm uses a\n",
      "        random point near the midpoint of two points that has to be\n",
      "        further sampled. Hence the same plots can appear slightly\n",
      "        different.\n",
      "    \n",
      "    depth : int, optional\n",
      "        Recursion depth of the adaptive algorithm. A depth of value\n",
      "        `n` samples a maximum of `2^{n}` points.\n",
      "    \n",
      "        If the ``adaptive`` flag is set to ``False``, this will be\n",
      "        ignored.\n",
      "    \n",
      "    nb_of_points : int, optional\n",
      "        Used when the ``adaptive`` is set to ``False``. The function\n",
      "        is uniformly sampled at ``nb_of_points`` number of points.\n",
      "    \n",
      "        If the ``adaptive`` flag is set to ``True``, this will be\n",
      "        ignored.\n",
      "    \n",
      "    size : (float, float), optional\n",
      "        A tuple in the form (width, height) in inches to specify the size of\n",
      "        the overall figure. The default value is set to ``None``, meaning\n",
      "        the size will be set by the default backend.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    .. plot::\n",
      "       :context: close-figs\n",
      "       :format: doctest\n",
      "       :include-source: True\n",
      "    \n",
      "       >>> from sympy import symbols\n",
      "       >>> from sympy.plotting import plot\n",
      "       >>> x = symbols('x')\n",
      "    \n",
      "    Single Plot\n",
      "    \n",
      "    .. plot::\n",
      "       :context: close-figs\n",
      "       :format: doctest\n",
      "       :include-source: True\n",
      "    \n",
      "       >>> plot(x**2, (x, -5, 5))\n",
      "       Plot object containing:\n",
      "       [0]: cartesian line: x**2 for x over (-5.0, 5.0)\n",
      "    \n",
      "    Multiple plots with single range.\n",
      "    \n",
      "    .. plot::\n",
      "       :context: close-figs\n",
      "       :format: doctest\n",
      "       :include-source: True\n",
      "    \n",
      "       >>> plot(x, x**2, x**3, (x, -5, 5))\n",
      "       Plot object containing:\n",
      "       [0]: cartesian line: x for x over (-5.0, 5.0)\n",
      "       [1]: cartesian line: x**2 for x over (-5.0, 5.0)\n",
      "       [2]: cartesian line: x**3 for x over (-5.0, 5.0)\n",
      "    \n",
      "    Multiple plots with different ranges.\n",
      "    \n",
      "    .. plot::\n",
      "       :context: close-figs\n",
      "       :format: doctest\n",
      "       :include-source: True\n",
      "    \n",
      "       >>> plot((x**2, (x, -6, 6)), (x, (x, -5, 5)))\n",
      "       Plot object containing:\n",
      "       [0]: cartesian line: x**2 for x over (-6.0, 6.0)\n",
      "       [1]: cartesian line: x for x over (-5.0, 5.0)\n",
      "    \n",
      "    No adaptive sampling.\n",
      "    \n",
      "    .. plot::\n",
      "       :context: close-figs\n",
      "       :format: doctest\n",
      "       :include-source: True\n",
      "    \n",
      "       >>> plot(x**2, adaptive=False, nb_of_points=400)\n",
      "       Plot object containing:\n",
      "       [0]: cartesian line: x**2 for x over (-10.0, 10.0)\n",
      "    \n",
      "    See Also\n",
      "    ========\n",
      "    \n",
      "    Plot, LineOver1DRangeSeries\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x77d1b258ad90>"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot((ln(x)-1)/x,ylim=(-3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(ln(x)-1)/x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\log{\\left(x \\right)} - 2}{x^{2}}$"
      ],
      "text/plain": [
       "-(log(x) - 2)/x**2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=symbols(\"a\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr1=-x**3+a*x-1/S(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x - x^{3} - \\frac{1}{4}$"
      ],
      "text/plain": [
       "a*x - x**3 - 1/4"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a - 3 x^{2}$"
      ],
      "text/plain": [
       "a - 3*x**2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr1,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbb{R} \\cap \\left\\{- \\frac{\\sqrt{3} \\sqrt{a}}{3}, \\frac{\\sqrt{3} \\sqrt{a}}{3}\\right\\}$"
      ],
      "text/plain": [
       "Intersection({-sqrt(3)*sqrt(a)/3, sqrt(3)*sqrt(a)/3}, Reals)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(\\frac{3}{4}, \\infty\\right)$"
      ],
      "text/plain": [
       "Interval.open(3/4, oo)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(expr1.subs(x,sqrt(a/3))>0,a,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle e a - e^{3} - \\frac{1}{4}$"
      ],
      "text/plain": [
       "E*a - exp(3) - 1/4"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr1.subs(x,exp(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, \\frac{1 + 4 e^{3}}{4 e}\\right)$"
      ],
      "text/plain": [
       "Interval.open(-oo, (1 + 4*exp(3))*exp(-1)/4)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(expr1.subs(x,exp(1))<0,a,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(\\frac{3}{4}, \\frac{1 + 4 e^{3}}{4 e}\\right)$"
      ],
      "text/plain": [
       "Interval.open(3/4, (1 + 4*exp(3))*exp(-1)/4)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A&B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-1, \\frac{1}{2}\\right\\}$"
      ],
      "text/plain": [
       "{-1, 1/2}"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(expr1.subs(a,3/S(4)),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{1 + 4 e^{3}}{4 e}\\right\\}$"
      ],
      "text/plain": [
       "{(1 + 4*exp(3))*exp(-1)/4}"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(expr1.subs(x,exp(1)),a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(2*m*x+(m+n)*y+2*n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 m x}{m + n} + \\frac{2 n}{m + n} + y$"
      ],
      "text/plain": [
       "2*m*x/(m + n) + 2*n/(m + n) + y"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(-1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( \\frac{- 5 m^{2} - 10 m n - n^{2}}{5 m^{2} + 2 m n + n^{2}}, \\  \\frac{10 m^{2} - 2 n^{2}}{5 m^{2} + 2 m n + n^{2}}\\right)\\right\\}$"
      ],
      "text/plain": [
       "{((-5*m**2 - 10*m*n - n**2)/(5*m**2 + 2*m*n + n**2), (10*m**2 - 2*n**2)/(5*m**2 + 2*m*n + n**2))}"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linsolve([l.equation(x,y),l.perpendicular_line(A).equation(x,y)],[x,y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [],
   "source": [
    "H=Point(list(_)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{- 5 m^{2} - 10 m n - n^{2}}{5 m^{2} + 2 m n + n^{2}}, \\frac{10 m^{2} - 2 n^{2}}{5 m^{2} + 2 m n + n^{2}}\\right)$"
      ],
      "text/plain": [
       "Point2D((-5*m**2 - 10*m*n - n**2)/(5*m**2 + 2*m*n + n**2), (10*m**2 - 2*n**2)/(5*m**2 + 2*m*n + n**2))"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=(H.distance(B))**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{85 m^{2} + 106 m n + 41 n^{2}}{5 m^{2} + 2 m n + n^{2}}$"
      ],
      "text/plain": [
       "(85*m**2 + 106*m*n + 41*n**2)/(5*m**2 + 2*m*n + n**2)"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(check)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 41$"
      ],
      "text/plain": [
       "41"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check.subs({m:0})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 17$"
      ],
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 293,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check.subs({n:0})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{85 t^{2} + 106 t + 41}{5 t^{2} + 2 t + 1}$"
      ],
      "text/plain": [
       "(85*t**2 + 106*t + 41)/(5*t**2 + 2*t + 1)"
      ]
     },
     "execution_count": 294,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(check).subs({m**2:t**2,m*n:t,n**2:1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\frac{- \\frac{212 \\sqrt{10}}{15} + \\frac{17}{3} + 85 \\left(- \\frac{2 \\sqrt{10}}{15} - \\frac{1}{3}\\right)^{2}}{- \\frac{4 \\sqrt{10}}{15} + \\frac{1}{3} + 5 \\left(- \\frac{2 \\sqrt{10}}{15} - \\frac{1}{3}\\right)^{2}}, \\frac{85 \\left(- \\frac{1}{3} + \\frac{2 \\sqrt{10}}{15}\\right)^{2} + \\frac{17}{3} + \\frac{212 \\sqrt{10}}{15}}{5 \\left(- \\frac{1}{3} + \\frac{2 \\sqrt{10}}{15}\\right)^{2} + \\frac{1}{3} + \\frac{4 \\sqrt{10}}{15}}\\right]$"
      ],
      "text/plain": [
       "Interval((-212*sqrt(10)/15 + 17/3 + 85*(-2*sqrt(10)/15 - 1/3)**2)/(-4*sqrt(10)/15 + 1/3 + 5*(-2*sqrt(10)/15 - 1/3)**2), (85*(-1/3 + 2*sqrt(10)/15)**2 + 17/3 + 212*sqrt(10)/15)/(5*(-1/3 + 2*sqrt(10)/15)**2 + 1/3 + 4*sqrt(10)/15))"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(function_range(_,t,Reals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 23 - 6 \\sqrt{10}$"
      ],
      "text/plain": [
       "23 - 6*sqrt(10)"
      ]
     },
     "execution_count": 298,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nsimplify(answer.inf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(2*x**2+1)*(x-1/x)**6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(x - \\frac{1}{x}\\right)^{6} \\cdot \\left(2 x^{2} + 1\\right)$"
      ],
      "text/plain": [
       "(x - 1/x)**6*(2*x**2 + 1)"
      ]
     },
     "execution_count": 302,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 x^{8} - 11 x^{6} + 24 x^{4} - 25 x^{2} + 10 + \\frac{3}{x^{2}} - \\frac{4}{x^{4}} + \\frac{1}{x^{6}}$"
      ],
      "text/plain": [
       "2*x**8 - 11*x**6 + 24*x**4 - 25*x**2 + 10 + 3/x**2 - 4/x**4 + x**(-6)"
      ]
     },
     "execution_count": 303,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.sphere\n",
    "from geometry3D.sphere import Sphere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [],
   "source": [
    "r,r1,r2=symbols(\"r,r1,r2\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [],
   "source": [
    "sphere=Sphere(Point(0,0,0),r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 \\pi r^{2}$"
      ],
      "text/plain": [
       "4*pi*r**2"
      ]
     },
     "execution_count": 312,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sphere.surface_area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.frustum_cone\n",
    "from geometry3D.frustum_cone import FrustumCone"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [],
   "source": [
    "cone_frustum=FrustumCone(r1,r2,2*r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\pi r_{1}^{2} + \\pi r_{2}^{2} + \\pi \\sqrt{4 r^{2} + \\left(r_{1} - r_{2}\\right)^{2}} \\left(r_{1} + r_{2}\\right)}{4 \\pi r^{2}}$"
      ],
      "text/plain": [
       "(pi*r1**2 + pi*r2**2 + pi*sqrt(4*r**2 + (r1 - r2)**2)*(r1 + r2))/(4*pi*r**2)"
      ]
     },
     "execution_count": 317,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone_frustum.surface_area/sphere.surface_area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{r_{1}^{2} + r_{2}^{2} + \\sqrt{4 r^{2} + \\left(r_{1} - r_{2}\\right)^{2}} \\left(r_{1} + r_{2}\\right)}{4 r^{2}}$"
      ],
      "text/plain": [
       "(r1**2 + r2**2 + sqrt(4*r**2 + (r1 - r2)**2)*(r1 + r2))/(4*r**2)"
      ]
     },
     "execution_count": 318,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( \\frac{r \\left(-1 + \\sqrt{5}\\right)}{2}, \\  r \\left(\\frac{1}{2} + \\frac{\\sqrt{5}}{2}\\right)\\right), \\left( \\frac{r \\left(1 + \\sqrt{5}\\right)}{2}, \\  r \\left(- \\frac{1}{2} + \\frac{\\sqrt{5}}{2}\\right)\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(r*(-1 + sqrt(5))/2, r*(1/2 + sqrt(5)/2)), (r*(1 + sqrt(5))/2, r*(-1/2 + sqrt(5)/2))}"
      ]
     },
     "execution_count": 319,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nonlinsolve([_-2,r1*r2-r**2],[r1,r2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=dict(zip([r1,r2],list(_)[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{r1: r*(-1 + sqrt(5))/2, r2: r*(1/2 + sqrt(5)/2)}"
      ]
     },
     "execution_count": 321,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\pi r^{2}}{\\frac{\\pi r^{2} \\left(-1 + \\sqrt{5}\\right)^{2}}{4} + \\frac{\\pi r^{2} \\left(-1 + \\sqrt{5}\\right) \\left(\\frac{1}{2} + \\frac{\\sqrt{5}}{2}\\right)}{2} + \\pi r^{2} \\left(\\frac{1}{2} + \\frac{\\sqrt{5}}{2}\\right)^{2}}$"
      ],
      "text/plain": [
       "2*pi*r**2/(pi*r**2*(-1 + sqrt(5))**2/4 + pi*r**2*(-1 + sqrt(5))*(1/2 + sqrt(5)/2)/2 + pi*r**2*(1/2 + sqrt(5)/2)**2)"
      ]
     },
     "execution_count": 323,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sphere.volume/cone_frustum.volume.subs(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{2}$"
      ],
      "text/plain": [
       "1/2"
      ]
     },
     "execution_count": 324,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function Hypergeometric in module sympy.stats.frv_types:\n",
      "\n",
      "Hypergeometric(name, N, m, n)\n",
      "    Create a Finite Random Variable representing a hypergeometric distribution.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    N : Positive Integer\n",
      "      Represents finite population of size N.\n",
      "    m : Positive Integer\n",
      "      Represents number of trials with required feature.\n",
      "    n : Positive Integer\n",
      "      Represents numbers of draws.\n",
      "    \n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy.stats import Hypergeometric, density\n",
      "    \n",
      "    >>> X = Hypergeometric('X', 10, 5, 3) # 10 marbles, 5 white (success), 3 draws\n",
      "    >>> density(X).dict\n",
      "    {0: 1/12, 1: 5/12, 2: 5/12, 3: 1/12}\n",
      "    \n",
      "    Returns\n",
      "    =======\n",
      "    \n",
      "    RandomSymbol\n",
      "    \n",
      "    References\n",
      "    ==========\n",
      "    \n",
      "    .. [1] https://en.wikipedia.org/wiki/Hypergeometric_distribution\n",
      "    .. [2] http://mathworld.wolfram.com/HypergeometricDistribution.html\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Hypergeometric)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {},
   "outputs": [],
   "source": [
    "N,m=symbols(\"N,m\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Hypergeometric(\"X\",N,m,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.stats import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{m {\\binom{N - m}{5}} + 5 \\left(N - m\\right) {\\binom{m}{5}} + 2 {\\binom{m}{2}} {\\binom{N - m}{4}} + 3 {\\binom{m}{3}} {\\binom{N - m}{3}} + 4 {\\binom{m}{4}} {\\binom{N - m}{2}} + 6 {\\binom{m}{6}}}{{\\binom{N}{6}}}$"
      ],
      "text/plain": [
       "(m*binomial(N - m, 5) + 5*(N - m)*binomial(m, 5) + 2*binomial(m, 2)*binomial(N - m, 4) + 3*binomial(m, 3)*binomial(N - m, 3) + 4*binomial(m, 4)*binomial(N - m, 2) + 6*binomial(m, 6))/binomial(N, 6)"
      ]
     },
     "execution_count": 330,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{6 m}{N}$"
      ],
      "text/plain": [
       "6*m/N"
      ]
     },
     "execution_count": 331,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y=Binomial(\"Y\",3,p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 p$"
      ],
      "text/plain": [
       "3*p"
      ]
     },
     "execution_count": 334,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(E(Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(1 - p\\right)^{3}$"
      ],
      "text/plain": [
       "(1 - p)**3"
      ]
     },
     "execution_count": 335,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P(Eq(Y,0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{0.3, 1.35 - 0.606217782649107 i, 1.35 + 0.606217782649107 i\\right\\}$"
      ],
      "text/plain": [
       "{0.3, 1.35 - 0.606217782649107*I, 1.35 + 0.606217782649107*I}"
      ]
     },
     "execution_count": 336,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_-0.343,p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.343$"
      ],
      "text/plain": [
       "0.343000000000000"
      ]
     },
     "execution_count": 338,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S(0.7)**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "metadata": {},
   "outputs": [],
   "source": [
    "cube=Cube(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(0, 0, 0\\right), \\  \\operatorname{Point3D}\\left(1, 0, 0\\right), \\  \\operatorname{Point3D}\\left(1, 1, 0\\right), \\  \\operatorname{Point3D}\\left(0, 1, 0\\right), \\  \\operatorname{Point3D}\\left(0, 0, 1\\right), \\  \\operatorname{Point3D}\\left(1, 0, 1\\right), \\  \\operatorname{Point3D}\\left(1, 1, 1\\right), \\  \\operatorname{Point3D}\\left(0, 1, 1\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(0, 0, 0), Point3D(1, 0, 0), Point3D(1, 1, 0), Point3D(0, 1, 0), Point3D(0, 0, 1), Point3D(1, 0, 1), Point3D(1, 1, 1), Point3D(0, 1, 1))"
      ]
     },
     "execution_count": 340,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cube.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "metadata": {},
   "outputs": [],
   "source": [
    "D,A,B,C,D1,A1,B1,C1=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "metadata": {},
   "outputs": [],
   "source": [
    "F=(A+D)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=(A+B)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=t*D1+(1-t)*C1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 347,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 1 - t, 1\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 1 - t, 1)"
      ]
     },
     "execution_count": 347,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport excel_function_package.data\n",
    "\n",
    "from excel_function_package.data import Data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_EF=Data(Line(E,F).direction_ratio)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 356,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1/2, -1/2, 0]"
      ]
     },
     "execution_count": 356,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec_EF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_PE=Data(Line(E,P).direction_ratio)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 358,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, 1/2 - t, 1]"
      ]
     },
     "execution_count": 358,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec_PE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1/2, t/2 - 1/4, 0]"
      ]
     },
     "execution_count": 359,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec_EF*vec_PE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{t}{2} + \\frac{1}{4}$"
      ],
      "text/plain": [
       "t/2 + 1/4"
      ]
     },
     "execution_count": 360,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{asin}{\\left(\\frac{\\sqrt{3} \\cdot \\left(\\frac{7}{4} - \\frac{t}{2}\\right)}{3 \\sqrt{\\left(\\frac{t}{2} - \\frac{3}{4}\\right)^{2} + \\frac{1}{2}}} \\right)}$"
      ],
      "text/plain": [
       "asin(sqrt(3)*(7/4 - t/2)/(3*sqrt((t/2 - 3/4)**2 + 1/2)))"
      ]
     },
     "execution_count": 363,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(E,F,P).angle_between(Line(A1,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=sin(_)-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 365,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{3} \\cdot \\left(\\frac{7}{4} - \\frac{t}{2}\\right)}{3 \\sqrt{\\left(\\frac{t}{2} - \\frac{3}{4}\\right)^{2} + \\frac{1}{2}}} - 1$"
      ],
      "text/plain": [
       "sqrt(3)*(7/4 - t/2)/(3*sqrt((t/2 - 3/4)**2 + 1/2)) - 1"
      ]
     },
     "execution_count": 365,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{1}{2}\\right\\}$"
      ],
      "text/plain": [
       "{1/2}"
      ]
     },
     "execution_count": 366,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(check,t,Interval(0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "RegularPolygon((0,0),)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.polygon3D \n",
    "from geometry3D.polygon3D import Polygon3D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyramid=Pyramid(A,Polygon3D(E,F,C1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{9 \\pi}{2}$"
      ],
      "text/plain": [
       "9*pi/2"
      ]
     },
     "execution_count": 371,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pyramid.circumsphere.surface_area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{\\left|{\\sqrt{\\left(2 t - 3\\right)^{2} + 8}}\\right|}$"
      ],
      "text/plain": [
       "1/Abs(sqrt((2*t - 3)**2 + 8))"
      ]
     },
     "execution_count": 372,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.distance(Plane(E,F,P))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=Function(\"f\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 n - 1$"
      ],
      "text/plain": [
       "2*n - 1"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rsolve(f(n)-(n**2-(n-1)**2),f(n),{f(1):1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "cn=(2*n-1)*3**n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3^{n} \\left(2 n - 1\\right)$"
      ],
      "text/plain": [
       "3**n*(2*n - 1)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{3^{n + 1}}{2} + \\frac{3 \\cdot \\left(2 \\cdot 3^{n} n - 3^{n} + 1\\right)}{2} + \\frac{3}{2}$"
      ],
      "text/plain": [
       "-3**(n + 1)/2 + 3*(2*3**n*n - 3**n + 1)/2 + 3/2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(cn,(n,1,n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 \\cdot 3^{n} n - 3 \\cdot 3^{n} + 3$"
      ],
      "text/plain": [
       "3*3**n*n - 3*3**n + 3"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expand(_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [],
   "source": [
    "tri=Polygon((0,0),(sqrt(3),0),(0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg xmlns=\"http://www.w3.org/2000/svg\"\n",
       "            xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n",
       "            width=\"100.0\" height=\"100.0\" viewBox=\"-0.173205080756888 -0.173205080756888 2.07846096908265 1.34641016151378\"\n",
       "            preserveAspectRatio=\"xMinYMin meet\">\n",
       "            <defs>\n",
       "                <marker id=\"markerCircle\" markerWidth=\"8\" markerHeight=\"8\"\n",
       "                    refx=\"5\" refy=\"5\" markerUnits=\"strokeWidth\">\n",
       "                    <circle cx=\"5\" cy=\"5\" r=\"1.5\" style=\"stroke: none; fill:#000000;\"/>\n",
       "                </marker>\n",
       "                <marker id=\"markerArrow\" markerWidth=\"13\" markerHeight=\"13\" refx=\"2\" refy=\"4\"\n",
       "                       orient=\"auto\" markerUnits=\"strokeWidth\">\n",
       "                    <path d=\"M2,2 L2,6 L6,4\" style=\"fill: #000000;\" />\n",
       "                </marker>\n",
       "                <marker id=\"markerReverseArrow\" markerWidth=\"13\" markerHeight=\"13\" refx=\"6\" refy=\"4\"\n",
       "                       orient=\"auto\" markerUnits=\"strokeWidth\">\n",
       "                    <path d=\"M6,2 L6,6 L2,4\" style=\"fill: #000000;\" />\n",
       "                </marker>\n",
       "            </defs><g transform=\"matrix(1,0,0,-1,0,1.00000000000000)\"><path fill-rule=\"evenodd\" fill=\"#66cc99\" stroke=\"#555555\" stroke-width=\"0.0415692193816531\" opacity=\"0.6\" d=\"M 0,0 L 1.73205080756888,0 L 0,1.00000000000000 z\" /></g></svg>"
      ],
      "text/latex": [
       "$\\displaystyle \\operatorname{Triangle}\\left(\\operatorname{Point2D}\\left(0, 0\\right), \\operatorname{Point2D}\\left(\\sqrt{3}, 0\\right), \\operatorname{Point2D}\\left(0, 1\\right)\\right)$"
      ],
      "text/plain": [
       "Triangle(Point2D(0, 0), Point2D(sqrt(3), 0), Point2D(0, 1))"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyr=Pyramid(Point(sqrt(3)/6,1/S(2),sqrt(6)/3),tri)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Tetrahedron}\\left(\\operatorname{Point3D}\\left(\\frac{\\sqrt{3}}{6}, \\frac{1}{2}, \\frac{\\sqrt{6}}{3}\\right), \\operatorname{Point3D}\\left(0, 0, 0\\right), \\operatorname{Point3D}\\left(\\sqrt{3}, 0, 0\\right), \\operatorname{Point3D}\\left(0, 1, 0\\right)\\right)$"
      ],
      "text/plain": [
       "Tetrahedron(Point3D(sqrt(3)/6, 1/2, sqrt(6)/3), Point3D(0, 0, 0), Point3D(sqrt(3), 0, 0), Point3D(0, 1, 0))"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pyr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [],
   "source": [
    "P,B,C,A=pyr.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [],
   "source": [
    "Q=(A+C)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [],
   "source": [
    "M=(C+2*B)/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{\\sqrt{3}}{2}, \\frac{1}{2}, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(sqrt(3)/2, 1/2, 0)"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q-B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{\\sqrt{3}}{3}, -1, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(sqrt(3)/3, -1, 0)"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M-A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(- \\frac{\\sqrt{3}}{6}, \\frac{1}{2}, - \\frac{\\sqrt{6}}{3}\\right)$"
      ],
      "text/plain": [
       "Point3D(-sqrt(3)/6, 1/2, -sqrt(6)/3)"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A-P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 1, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 1, 0)"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A-B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\frac{\\sqrt{6}}{3}, \\  0, \\  - \\frac{\\sqrt{3}}{6}\\right)$"
      ],
      "text/plain": [
       "(sqrt(6)/3, 0, -sqrt(3)/6)"
      ]
     },
     "execution_count": 244,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(A,P,B).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(\\frac{\\sqrt{6}}{3} \\right)}$"
      ],
      "text/plain": [
       "acos(sqrt(6)/3)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(A,P,B).angle_between(Plane(A,P,M))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43.75"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(45*3+40)/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "ellip=Ellipse(Point(0,0),hradius=2,eccentricity=1/S(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg xmlns=\"http://www.w3.org/2000/svg\"\n",
       "            xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n",
       "            width=\"100.0\" height=\"100.0\" viewBox=\"-2.40000000000000 -2.13205080756888 4.80000000000000 4.26410161513775\"\n",
       "            preserveAspectRatio=\"xMinYMin meet\">\n",
       "            <defs>\n",
       "                <marker id=\"markerCircle\" markerWidth=\"8\" markerHeight=\"8\"\n",
       "                    refx=\"5\" refy=\"5\" markerUnits=\"strokeWidth\">\n",
       "                    <circle cx=\"5\" cy=\"5\" r=\"1.5\" style=\"stroke: none; fill:#000000;\"/>\n",
       "                </marker>\n",
       "                <marker id=\"markerArrow\" markerWidth=\"13\" markerHeight=\"13\" refx=\"2\" refy=\"4\"\n",
       "                       orient=\"auto\" markerUnits=\"strokeWidth\">\n",
       "                    <path d=\"M2,2 L2,6 L6,4\" style=\"fill: #000000;\" />\n",
       "                </marker>\n",
       "                <marker id=\"markerReverseArrow\" markerWidth=\"13\" markerHeight=\"13\" refx=\"6\" refy=\"4\"\n",
       "                       orient=\"auto\" markerUnits=\"strokeWidth\">\n",
       "                    <path d=\"M6,2 L6,6 L2,4\" style=\"fill: #000000;\" />\n",
       "                </marker>\n",
       "            </defs><g transform=\"matrix(1,0,0,-1,0,0)\"><ellipse fill=\"#66cc99\" stroke=\"#555555\" stroke-width=\"0.0960000000000000\" opacity=\"0.6\" cx=\"0\" cy=\"0\" rx=\"2.00000000000000\" ry=\"1.73205080756888\"/></g></svg>"
      ],
      "text/latex": [
       "$\\displaystyle \\operatorname{Ellipse}\\left(\\operatorname{Point2D}\\left(0, 0\\right), 2, \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "Ellipse(Point2D(0, 0), 2, sqrt(3))"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ellip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2}}{4} + \\frac{y^{2}}{3} - 1$"
      ],
      "text/plain": [
       "x**2/4 + y**2/3 - 1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ellip.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=Point(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1,l2=ellip.tangent_lines(P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{- 3 x \\sqrt{3 x^{2} + 4 y^{2} - 12} + y \\left(3 x^{2} + 4 y^{2}\\right) - 12 y}{x \\left(3 x^{2} + 4 y^{2}\\right) - 12 x + 4 y \\sqrt{3 x^{2} + 4 y^{2} - 12}}$"
      ],
      "text/plain": [
       "(-3*x*sqrt(3*x**2 + 4*y**2 - 12) + y*(3*x**2 + 4*y**2) - 12*y)/(x*(3*x**2 + 4*y**2) - 12*x + 4*y*sqrt(3*x**2 + 4*y**2 - 12))"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1.slope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{- 3 x \\sqrt{3 x^{2} + 4 y^{2} - 12} - y \\left(3 x^{2} + 4 y^{2}\\right) + 12 y}{- x \\left(3 x^{2} + 4 y^{2}\\right) + 12 x + 4 y \\sqrt{3 x^{2} + 4 y^{2} - 12}}$"
      ],
      "text/plain": [
       "(-3*x*sqrt(3*x**2 + 4*y**2 - 12) - y*(3*x**2 + 4*y**2) + 12*y)/(-x*(3*x**2 + 4*y**2) + 12*x + 4*y*sqrt(3*x**2 + 4*y**2 - 12))"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l2.slope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{y^{2} - 3}{x^{2} - 4}$"
      ],
      "text/plain": [
       "(y**2 - 3)/(x**2 - 4)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(l1.slope*l2.slope)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "eq=Eq(_,-3/S(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{y^{2} - 3}{x^{2} - 4} = - \\frac{3}{4}$"
      ],
      "text/plain": [
       "Eq((y**2 - 3)/(x**2 - 4), -3/4)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 x^{2} + 4 y^{2} - 24$"
      ],
      "text/plain": [
       "3*x**2 + 4*y**2 - 24"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify_equation(eq,fraction=True,expr=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "ellip2=Ellipse(Point(0,0),sqrt(8),sqrt(6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2}}{8} + \\frac{y^{2}}{6} - 1$"
      ],
      "text/plain": [
       "x**2/8 + y**2/6 - 1"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ellip2.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(ellip.hradius,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(2, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(2, 0)"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(-ellip.hradius,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(-2, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(-2, 0)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Point2D(2, 0),\n",
       " Point2D((-12*y*(x - 2)**2/(3*x**2 - 12*x + 4*y**2 + 12) + 2*y)/y, -12*y*(x - 2)/(3*x**2 - 12*x + 4*y**2 + 12))]"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line(P,A).intersection(ellip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(check[0].y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{12 y \\left(2 - x\\right)}{3 x^{2} - 12 x + 4 y^{2} + 12}$"
      ],
      "text/plain": [
       "12*y*(2 - x)/(3*x**2 - 12*x + 4*y**2 + 12)"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(check[1].y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "M=check[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{- \\frac{12 y \\left(x - 2\\right)^{2}}{3 x^{2} - 12 x + 4 y^{2} + 12} + 2 y}{y}, - \\frac{12 y \\left(x - 2\\right)}{3 x^{2} - 12 x + 4 y^{2} + 12}\\right)$"
      ],
      "text/plain": [
       "Point2D((-12*y*(x - 2)**2/(3*x**2 - 12*x + 4*y**2 + 12) + 2*y)/y, -12*y*(x - 2)/(3*x**2 - 12*x + 4*y**2 + 12))"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Point2D(-2, 0),\n",
       " Point2D((12*y*(x + 2)**2/(3*x**2 + 12*x + 4*y**2 + 12) - 2*y)/y, 12*y*(x + 2)/(3*x**2 + 12*x + 4*y**2 + 12))]"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line(P,B).intersection(ellip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(check[0].y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{12 y \\left(x + 2\\right)}{3 x^{2} + 12 x + 4 y^{2} + 12}$"
      ],
      "text/plain": [
       "12*y*(x + 2)/(3*x**2 + 12*x + 4*y**2 + 12)"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(check[1].y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "N=check[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{\\frac{12 y \\left(x + 2\\right)^{2}}{3 x^{2} + 12 x + 4 y^{2} + 12} - 2 y}{y}, \\frac{12 y \\left(x + 2\\right)}{3 x^{2} + 12 x + 4 y^{2} + 12}\\right)$"
      ],
      "text/plain": [
       "Point2D((12*y*(x + 2)**2/(3*x**2 + 12*x + 4*y**2 + 12) - 2*y)/y, 12*y*(x + 2)/(3*x**2 + 12*x + 4*y**2 + 12))"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "tri=Triangle(Point(0,0),M,N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{48 y \\left(3 x^{2} + 4 y^{2} - 12\\right)}{9 x^{4} + 24 x^{2} y^{2} - 72 x^{2} + 16 y^{4} + 96 y^{2} + 144}$"
      ],
      "text/plain": [
       "48*y*(3*x**2 + 4*y**2 - 12)/(9*x**4 + 24*x**2*y**2 - 72*x**2 + 16*y**4 + 96*y**2 + 144)"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tri.area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=simplify(expand(_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{576 y}{9 x^{4} + 24 x^{2} \\cdot \\left(6 - \\frac{3 x^{2}}{4}\\right) - 144 x^{2} + 16 \\left(6 - \\frac{3 x^{2}}{4}\\right)^{2} + 720}$"
      ],
      "text/plain": [
       "576*y/(9*x**4 + 24*x**2*(6 - 3*x**2/4) - 144*x**2 + 16*(6 - 3*x**2/4)**2 + 720)"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer.subs(y**2,(24-3*x**2)/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{4 y}{x^{2} - 9}$"
      ],
      "text/plain": [
       "-4*y/(x**2 - 9)"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(4*y/(x**2-9)).subs(x**2,(24-4*y**2)/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{4 y}{- \\frac{4 y^{2}}{3} - 1}$"
      ],
      "text/plain": [
       "4*y/(-4*y**2/3 - 1)"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{12 y}{4 y^{2} + 3}$"
      ],
      "text/plain": [
       "-12*y/(4*y**2 + 3)"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[- \\sqrt{3}, \\sqrt{3}\\right]$"
      ],
      "text/plain": [
       "Interval(-sqrt(3), sqrt(3))"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range(expr,y,Interval(-sqrt(6),sqrt(6)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "k=symbols(\"k\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(y-k*(x+2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 16 k^{2} x + x^{2} \\cdot \\left(4 k^{2} + 3\\right) + 4 \\cdot \\left(4 k^{2} - 3\\right)$"
      ],
      "text/plain": [
       "16*k**2*x + x**2*(4*k**2 + 3) + 4*(4*k**2 - 3)"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(l,ellip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{6 - 8 k^{2}}{4 k^{2} + 3}$"
      ],
      "text/plain": [
       "(6 - 8*k**2)/(4*k**2 + 3)"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(QuadraticFunction(_).roots)[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{- \\frac{8 y^{2}}{\\left(x + 2\\right)^{2}} + 6}{\\frac{4 y^{2}}{\\left(x + 2\\right)^{2}} + 3}$"
      ],
      "text/plain": [
       "(-8*y**2/(x + 2)**2 + 6)/(4*y**2/(x + 2)**2 + 3)"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.subs(k,y/(x+2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=expand(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\cdot \\left(3 x^{2} + 12 x - 4 y^{2} + 12\\right)}{3 x^{2} + 12 x + 4 y^{2} + 12}$"
      ],
      "text/plain": [
       "2*(3*x**2 + 12*x - 4*y**2 + 12)/(3*x**2 + 12*x + 4*y**2 + 12)"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2} + 2 x - 2}{x + 3}$"
      ],
      "text/plain": [
       "(x**2 + 2*x - 2)/(x + 3)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_.subs(y**2,(24-3*x**2)/4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 12 k y + y^{2} \\cdot \\left(4 k^{2} + 3\\right)$"
      ],
      "text/plain": [
       "-12*k*y + y**2*(4*k**2 + 3)"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(l,ellip,y=y,first=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{12 k}{4 k^{2} + 3}$"
      ],
      "text/plain": [
       "12*k/(4*k**2 + 3)"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(QuadraticFunction(_,x=y).roots)[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{12 y}{\\left(x + 2\\right) \\left(\\frac{4 \\cdot \\left(6 - \\frac{3 x^{2}}{4}\\right)}{\\left(x + 2\\right)^{2}} + 3\\right)}$"
      ],
      "text/plain": [
       "12*y/((x + 2)*(4*(6 - 3*x**2/4)/(x + 2)**2 + 3))"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.subs(k,y/(x+2)).subs(y**2,(24-3*x**2)/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{y \\left(x + 2\\right)}{x + 3}$"
      ],
      "text/plain": [
       "y*(x + 2)/(x + 3)"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=Point(m,n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 8 k x \\left(k m - n\\right) + x^{2} \\cdot \\left(4 k^{2} + 3\\right) + 4 \\left(k^{2} m^{2} - 2 k m n + n^{2} - 3\\right)$"
      ],
      "text/plain": [
       "-8*k*x*(k*m - n) + x**2*(4*k**2 + 3) + 4*(k**2*m**2 - 2*k*m*n + n**2 - 3)"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(Line(P,slope=k),ellip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\left(16 k^{2} + 12\\right) \\left(4 k^{2} m^{2} - 8 k m n + 4 n^{2} - 12\\right) + \\left(- 8 k^{2} m + 8 k n\\right)^{2}$"
      ],
      "text/plain": [
       "-(16*k**2 + 12)*(4*k**2*m**2 - 8*k*m*n + 4*n**2 - 12) + (-8*k**2*m + 8*k*n)**2"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 48 k^{2} m^{2} + 192 k^{2} + 96 k m n - 48 n^{2} + 144$"
      ],
      "text/plain": [
       "-48*k**2*m**2 + 192*k**2 + 96*k*m*n - 48*n**2 + 144"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle k^{2} \\cdot \\left(192 - 48 m^{2}\\right) + 96 k m n - 48 n^{2} + 144$"
      ],
      "text/plain": [
       "k**2*(192 - 48*m**2) + 96*k*m*n - 48*n**2 + 144"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect(_,k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{k^{2} \\cdot \\left(192 - 48 m^{2}\\right)}{48} + 2 k m n - n^{2} + 3$"
      ],
      "text/plain": [
       "k**2*(192 - 48*m**2)/48 + 2*k*m*n - n**2 + 3"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_/48"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle k^{2} \\cdot \\left(4 - m^{2}\\right) + 2 k m n - n^{2} + 3$"
      ],
      "text/plain": [
       "k**2*(4 - m**2) + 2*k*m*n - n**2 + 3"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 607,
   "metadata": {},
   "outputs": [],
   "source": [
    "g=lambda n:-sin(pi/2*n)+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 608,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 608,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 609,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=lambda n:1+-sin(pi/2*(-1-n))+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 610,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 610,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 611,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 6074$"
      ],
      "text/plain": [
       "6074"
      ]
     },
     "execution_count": 611,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(f(n)+g(n),(n,1,2025))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 老高考大题"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=symbols(\"a\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 517,
   "metadata": {},
   "outputs": [],
   "source": [
    "hyper=Hyperbola(Point(0,0),a,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 518,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - y^{2} - 1 + \\frac{x^{2}}{a^{2}}$"
      ],
      "text/plain": [
       "-y**2 - 1 + x**2/a**2"
      ]
     },
     "execution_count": 518,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hyper.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 520,
   "metadata": {},
   "outputs": [],
   "source": [
    "F1,F2=hyper.foci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 521,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(- \\sqrt{a^{2} + 1}, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(-sqrt(a**2 + 1), 0)"
      ]
     },
     "execution_count": 521,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 522,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\sqrt{a^{2} + 1}, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(sqrt(a**2 + 1), 0)"
      ]
     },
     "execution_count": 522,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 523,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1=Line(F1,slope=a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 524,
   "metadata": {},
   "outputs": [],
   "source": [
    "l2=Line(F2,slope=(1+a)/(1-a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 525,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Point2D(-sqrt(a**2 + 1) + (a**2*sqrt(a**2 + 1)/(a**4 - 1) - a*sqrt(a**2 + 1)/(a**4 - 1))/a, a**2*sqrt(a**2 + 1)/(a**4 - 1) - a*sqrt(a**2 + 1)/(a**4 - 1)),\n",
       " Point2D(-sqrt(a**2 + 1) + (-a**2*sqrt(a**2 + 1)/(a**4 - 1) - a*sqrt(a**2 + 1)/(a**4 - 1))/a, -a**2*sqrt(a**2 + 1)/(a**4 - 1) - a*sqrt(a**2 + 1)/(a**4 - 1))]"
      ]
     },
     "execution_count": 525,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1.intersection(hyper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 526,
   "metadata": {},
   "outputs": [],
   "source": [
    "points=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 527,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{a \\sqrt{a^{2} + 1} \\left(a^{3} + 1\\right)}{a^{4} - 1}$"
      ],
      "text/plain": [
       "-a*sqrt(a**2 + 1)*(a**3 + 1)/(a**4 - 1)"
      ]
     },
     "execution_count": 527,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(points[1].x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 528,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a \\left(- a - 1\\right) \\sqrt{a^{2} + 1}}{a^{4} - 1}$"
      ],
      "text/plain": [
       "a*(-a - 1)*sqrt(a**2 + 1)/(a**4 - 1)"
      ]
     },
     "execution_count": 528,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(points[1].y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 529,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,=Intersection(l1,l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 530,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{- a^{2} + 2 a + 1}{\\sqrt{a^{2} + 1}}, \\frac{2 a \\left(a + 1\\right)}{\\sqrt{a^{2} + 1}}\\right)$"
      ],
      "text/plain": [
       "Point2D((-a**2 + 2*a + 1)/sqrt(a**2 + 1), 2*a*(a + 1)/sqrt(a**2 + 1))"
      ]
     },
     "execution_count": 530,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 532,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\sqrt{2} \\left|{a}\\right|$"
      ],
      "text/plain": [
       "2*sqrt(2)*Abs(a)"
      ]
     },
     "execution_count": 532,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(A.distance(F2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{4 a^{2} \\left(a + 1\\right)^{2}}{a^{2} + 1} - 1 + \\frac{\\left(- a^{2} + 2 a + 1\\right)^{2}}{a^{2} \\left(a^{2} + 1\\right)}$"
      ],
      "text/plain": [
       "-4*a**2*(a + 1)**2/(a**2 + 1) - 1 + (-a**2 + 2*a + 1)**2/(a**2*(a**2 + 1))"
      ]
     },
     "execution_count": 411,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hyper.equation(x,y).subs({x:A.x,y:A.y})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 412,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{\\sqrt{2}}{2}\\right\\}$"
      ],
      "text/plain": [
       "{sqrt(2)/2}"
      ]
     },
     "execution_count": 412,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,a,Interval.open(0,oo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 413,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.core.function.UndefinedFunction"
      ]
     },
     "execution_count": 413,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 414,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 n + 1$"
      ],
      "text/plain": [
       "2*n + 1"
      ]
     },
     "execution_count": 414,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rsolve(f(n+1)+f(n)-(4*n+4),f(n),{f(1):3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 415,
   "metadata": {},
   "outputs": [],
   "source": [
    "bn=(-2)**(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 416,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-2\\right)^{2 n + 1}$"
      ],
      "text/plain": [
       "(-2)**(2*n + 1)"
      ]
     },
     "execution_count": 416,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 417,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -8$"
      ],
      "text/plain": [
       "-8"
      ]
     },
     "execution_count": 417,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bn.subs(n,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{8}{3} - \\frac{2 \\cdot 4^{n + 1}}{3}$"
      ],
      "text/plain": [
       "8/3 - 2*4**(n + 1)/3"
      ]
     },
     "execution_count": 418,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(bn,(n,1,n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 419,
   "metadata": {},
   "outputs": [],
   "source": [
    "sn=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 420,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{5, 6, \\ldots\\right\\}$"
      ],
      "text/plain": [
       "Range(5, oo, 1)"
      ]
     },
     "execution_count": 420,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(sn<-2024,n,Naturals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 533,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2024.0"
      ]
     },
     "execution_count": 533,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "759*8/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 534,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(-1,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 535,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(1,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 536,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=Point(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 537,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=Point(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 538,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=Point(0,0,sqrt(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 539,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyrad=Pyramid(P,Polygon(A,B,C,D))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 540,
   "metadata": {},
   "outputs": [],
   "source": [
    "P,A,B,C,D=pyrad.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 431,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 0, \\  - 2 \\sqrt{2}, \\  2\\right)$"
      ],
      "text/plain": [
       "(0, -2*sqrt(2), 2)"
      ]
     },
     "execution_count": 431,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,A,B).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 433,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec=Data(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 438,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=(P+D)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 439,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_CE=Data(Line(C,E).direction_ratio)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 440,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(vec_CE*vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\operatorname{asin}{\\left(\\frac{\\sqrt{22}}{11} \\right)}$"
      ],
      "text/plain": [
       "-asin(sqrt(22)/11)"
      ]
     },
     "execution_count": 443,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,C,D).angle_between(Line(P,B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 541,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\sqrt{2}, \\  2 \\sqrt{2}, \\  1\\right)$"
      ],
      "text/plain": [
       "(sqrt(2), 2*sqrt(2), 1)"
      ]
     },
     "execution_count": 541,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,C,D).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 444,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{0.01\\right\\}$"
      ],
      "text/plain": [
       "{0.01}"
      ]
     },
     "execution_count": 444,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(0.005+0.02+0.04+0.025+a-0.1,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 445,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.15"
      ]
     },
     "execution_count": 445,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.005*150+0.02*160+0.04*170+0.025*180+0.01*190"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 446,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Hypergeometric(\"X\",20,n,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 447,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.stats import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 448,
   "metadata": {},
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "Currently, probability queries are not supported for random variables with symbolic sized distributions.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_8595/908282467.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mP\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mEq\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/stats/rv.py\u001b[0m in \u001b[0;36mprobability\u001b[0;34m(condition, given_condition, numsamples, evaluate, **kwargs)\u001b[0m\n\u001b[1;32m    840\u001b[0m     \u001b[0;32mfrom\u001b[0m \u001b[0msympy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstats\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msymbolic_probability\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mProbability\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    841\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mevaluate\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 842\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mProbability\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcondition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgiven_condition\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdoit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    843\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mProbability\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcondition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgiven_condition\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    844\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/stats/symbolic_probability.py\u001b[0m in \u001b[0;36mdoit\u001b[0;34m(self, **hints)\u001b[0m\n\u001b[1;32m    117\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mProbability\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcondition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgiven_condition\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    118\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcondition\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprobability\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcondition\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    120\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'doit'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mfor_rewrite\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    121\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdoit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/stats/frv.py\u001b[0m in \u001b[0;36mprobability\u001b[0;34m(self, condition)\u001b[0m\n\u001b[1;32m    459\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_is_symbolic\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    460\u001b[0m             \u001b[0;31m#TODO: Implement the mechanism for handling queries for symbolic sized distributions.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 461\u001b[0;31m             raise NotImplementedError(\"Currently, probability queries are not \"\n\u001b[0m\u001b[1;32m    462\u001b[0m             \"supported for random variables with symbolic sized distributions.\")\n\u001b[1;32m    463\u001b[0m         \u001b[0mcondition\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrv_subs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcondition\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: Currently, probability queries are not supported for random variables with symbolic sized distributions."
     ]
    }
   ],
   "source": [
    "P(Eq(X,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 542,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=binomial(n,3)*binomial(20-n,7)/binomial(20,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 543,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{{\\binom{n}{3}} {\\binom{20 - n}{7}}}{184756}$"
      ],
      "text/plain": [
       "binomial(n, 3)*binomial(20 - n, 7)/184756"
      ]
     },
     "execution_count": 543,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 544,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{{\\binom{n}{3}} {\\binom{20 - n}{7}}}{{\\binom{21 - n}{7}} {\\binom{n - 1}{3}}}$"
      ],
      "text/plain": [
       "binomial(n, 3)*binomial(20 - n, 7)/(binomial(21 - n, 7)*binomial(n - 1, 3))"
      ]
     },
     "execution_count": 544,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr/expr.subs(n,n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 545,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{n \\left(n - 14\\right)}{\\left(n - 21\\right) \\left(n - 3\\right)}$"
      ],
      "text/plain": [
       "n*(n - 14)/((n - 21)*(n - 3))"
      ]
     },
     "execution_count": 545,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 546,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(3, \\frac{63}{10}\\right) \\cup \\left(21, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(3, 63/10), Interval.open(21, oo))"
      ]
     },
     "execution_count": 546,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_>1,n,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 456,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{{\\binom{n}{3}} {\\binom{20 - n}{7}}}{184756}$"
      ],
      "text/plain": [
       "binomial(n, 3)*binomial(20 - n, 7)/184756"
      ]
     },
     "execution_count": 456,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 457,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x77d1c6eeaa30>"
      ]
     },
     "execution_count": 457,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(n,3,13))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 547,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=symbols(\"a\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 548,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=exp(x)-x**2-a*x-cos(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 549,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - a x - x^{2} + e^{x} - \\cos{\\left(x \\right)}$"
      ],
      "text/plain": [
       "-a*x - x**2 + exp(x) - cos(x)"
      ]
     },
     "execution_count": 549,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 550,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle y = x$"
      ],
      "text/plain": [
       "Eq(y, x)"
      ]
     },
     "execution_count": 550,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_tangent(expr.subs(a,0),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 551,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - a - 2 x + e^{x} + \\sin{\\left(x \\right)}$"
      ],
      "text/plain": [
       "-a - 2*x + exp(x) + sin(x)"
      ]
     },
     "execution_count": 551,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 552,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle e^{x} + \\cos{\\left(x \\right)} - 2$"
      ],
      "text/plain": [
       "exp(x) + cos(x) - 2"
      ]
     },
     "execution_count": 552,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr,x,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 553,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 12 a^{2} - \\cos{\\left(4 a \\right)} + e^{- 4 a}$"
      ],
      "text/plain": [
       "-12*a**2 - cos(4*a) + exp(-4*a)"
      ]
     },
     "execution_count": 553,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,-4*a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 556,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - a \\left(a + 3\\right) - \\left(a + 3\\right)^{2} + e^{a + 3} - \\cos{\\left(a + 3 \\right)}$"
      ],
      "text/plain": [
       "-a*(a + 3) - (a + 3)**2 + exp(a + 3) - cos(a + 3)"
      ]
     },
     "execution_count": 556,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expr.subs(x,3+a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 557,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 2 a^{2} - 9 a + e^{3} e^{a} - \\cos{\\left(a + 3 \\right)} - 9$"
      ],
      "text/plain": [
       "-2*a**2 - 9*a + exp(3)*exp(a) - cos(a + 3) - 9"
      ]
     },
     "execution_count": 557,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 463,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x77d1b16fb3a0>"
      ]
     },
     "execution_count": 463,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr.subs(a,-1),(x,-3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 558,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b=symbols(\"a,b,\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 559,
   "metadata": {},
   "outputs": [],
   "source": [
    "ellip=Ellipse(Point(0,0),a,eccentricity=sqrt(8)/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 560,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -1 + \\frac{x^{2}}{a^{2}} + \\frac{9 y^{2}}{a^{2}}$"
      ],
      "text/plain": [
       "-1 + x**2/a**2 + 9*y**2/a**2"
      ]
     },
     "execution_count": 560,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ellip.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "metadata": {},
   "outputs": [],
   "source": [
    "M=Point(3,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 562,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 562,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k in Reals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 564,
   "metadata": {},
   "outputs": [],
   "source": [
    "ellip=Ellipse(Point(0,0),a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 565,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 6 a^{2} x - a^{2} \\left(b - 3\\right) \\left(b + 3\\right) + x^{2} \\left(a^{2} + b^{2}\\right)$"
      ],
      "text/plain": [
       "-6*a**2*x - a**2*(b - 3)*(b + 3) + x**2*(a**2 + b**2)"
      ]
     },
     "execution_count": 565,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(Line(M,slope=1),ellip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 566,
   "metadata": {},
   "outputs": [],
   "source": [
    "P,Q=Intersection(ellip,Line(M,slope=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 567,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{8 a^{2} b^{2} \\left(a^{2} + b^{2} - 9\\right)}{\\left(a^{2} + b^{2}\\right)^{2}}$"
      ],
      "text/plain": [
       "8*a**2*b**2*(a**2 + b**2 - 9)/(a**2 + b**2)**2"
      ]
     },
     "execution_count": 567,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(P.distance(Q))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{4 a^{2}}{5} - \\frac{324}{5}$"
      ],
      "text/plain": [
       "4*a**2/5 - 324/5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(P.distance(Q))**2-(27*sqrt(2)/5)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 480,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{81\\right\\}$"
      ],
      "text/plain": [
       "{81}"
      ]
     },
     "execution_count": 480,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,a**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 481,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2}}{81} + \\frac{y^{2}}{9} - 1$"
      ],
      "text/plain": [
       "x**2/81 + y**2/9 - 1"
      ]
     },
     "execution_count": 481,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ellip.equation().subs(a**2,81)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 568,
   "metadata": {},
   "outputs": [],
   "source": [
    "ellip=Ellipse(Point(0,0),9,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 569,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(-9,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 570,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(9,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 571,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 571,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Point(3,sqrt(8)) in ellip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 572,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 54 k^{2} x + x^{2} \\cdot \\left(9 k^{2} + 1\\right) + 81 \\left(k - 1\\right) \\left(k + 1\\right)$"
      ],
      "text/plain": [
       "-54*k**2*x + x**2*(9*k**2 + 1) + 81*(k - 1)*(k + 1)"
      ]
     },
     "execution_count": 572,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(Line(M,slope=k),ellip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 486,
   "metadata": {},
   "outputs": [],
   "source": [
    "P,Q=Intersection(ellip,Line(M,slope=k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 487,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\operatorname{Point2D}\\left(27, \\frac{12 k \\left(- 12 k^{2} + \\sqrt{8 k^{2} + 1} - 1\\right)}{6 k^{2} \\sqrt{8 k^{2} + 1} - 10 k^{2} + \\sqrt{8 k^{2} + 1} - 1}\\right)\\right\\}$"
      ],
      "text/plain": [
       "{Point2D(27, 12*k*(-12*k**2 + sqrt(8*k**2 + 1) - 1)/(6*k**2*sqrt(8*k**2 + 1) - 10*k**2 + sqrt(8*k**2 + 1) - 1))}"
      ]
     },
     "execution_count": 487,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Intersection(Line(A,P),Line(B,Q))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 488,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Curve in module sympy.geometry.curve:\n",
      "\n",
      "class Curve(sympy.geometry.entity.GeometrySet)\n",
      " |  Curve(function, limits)\n",
      " |  \n",
      " |  A curve in space.\n",
      " |  \n",
      " |  A curve is defined by parametric functions for the coordinates, a\n",
      " |  parameter and the lower and upper bounds for the parameter value.\n",
      " |  \n",
      " |  Parameters\n",
      " |  ==========\n",
      " |  \n",
      " |  function : list of functions\n",
      " |  limits : 3-tuple\n",
      " |      Function parameter and lower and upper bounds.\n",
      " |  \n",
      " |  Attributes\n",
      " |  ==========\n",
      " |  \n",
      " |  functions\n",
      " |  parameter\n",
      " |  limits\n",
      " |  \n",
      " |  Raises\n",
      " |  ======\n",
      " |  \n",
      " |  ValueError\n",
      " |      When `functions` are specified incorrectly.\n",
      " |      When `limits` are specified incorrectly.\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Curve, sin, cos, interpolate\n",
      " |  >>> from sympy.abc import t, a\n",
      " |  >>> C = Curve((sin(t), cos(t)), (t, 0, 2))\n",
      " |  >>> C.functions\n",
      " |  (sin(t), cos(t))\n",
      " |  >>> C.limits\n",
      " |  (t, 0, 2)\n",
      " |  >>> C.parameter\n",
      " |  t\n",
      " |  >>> C = Curve((t, interpolate([1, 4, 9, 16], t)), (t, 0, 1)); C\n",
      " |  Curve((t, t**2), (t, 0, 1))\n",
      " |  >>> C.subs(t, 4)\n",
      " |  Point2D(4, 16)\n",
      " |  >>> C.arbitrary_point(a)\n",
      " |  Point2D(a, a**2)\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  \n",
      " |  sympy.core.function.Function\n",
      " |  sympy.polys.polyfuncs.interpolate\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Curve\n",
      " |      sympy.geometry.entity.GeometrySet\n",
      " |      sympy.geometry.entity.GeometryEntity\n",
      " |      sympy.sets.sets.Set\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __call__(self, f)\n",
      " |      Call self as a function.\n",
      " |  \n",
      " |  arbitrary_point(self, parameter='t')\n",
      " |      A parameterized point on the curve.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      parameter : str or Symbol, optional\n",
      " |          Default value is 't'.\n",
      " |          The Curve's parameter is selected with None or self.parameter\n",
      " |          otherwise the provided symbol is used.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Point :\n",
      " |          Returns a point in parametric form.\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      ValueError\n",
      " |          When `parameter` already appears in the functions.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Curve, Symbol\n",
      " |      >>> from sympy.abc import s\n",
      " |      >>> C = Curve([2*s, s**2], (s, 0, 2))\n",
      " |      >>> C.arbitrary_point()\n",
      " |      Point2D(2*t, t**2)\n",
      " |      >>> C.arbitrary_point(C.parameter)\n",
      " |      Point2D(2*s, s**2)\n",
      " |      >>> C.arbitrary_point(None)\n",
      " |      Point2D(2*s, s**2)\n",
      " |      >>> C.arbitrary_point(Symbol('a'))\n",
      " |      Point2D(2*a, a**2)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.point.Point\n",
      " |  \n",
      " |  plot_interval(self, parameter='t')\n",
      " |      The plot interval for the default geometric plot of the curve.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      parameter : str or Symbol, optional\n",
      " |          Default value is 't';\n",
      " |          otherwise the provided symbol is used.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      List :\n",
      " |          the plot interval as below:\n",
      " |              [parameter, lower_bound, upper_bound]\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Curve, sin\n",
      " |      >>> from sympy.abc import x, s\n",
      " |      >>> Curve((x, sin(x)), (x, 1, 2)).plot_interval()\n",
      " |      [t, 1, 2]\n",
      " |      >>> Curve((x, sin(x)), (x, 1, 2)).plot_interval(s)\n",
      " |      [s, 1, 2]\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      limits : Returns limits of the parameter interval\n",
      " |  \n",
      " |  rotate(self, angle=0, pt=None)\n",
      " |      This function is used to rotate a curve along given point ``pt`` at given angle(in radian).\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      angle :\n",
      " |          the angle at which the curve will be rotated(in radian) in counterclockwise direction.\n",
      " |          default value of angle is 0.\n",
      " |      \n",
      " |      pt : Point\n",
      " |          the point along which the curve will be rotated.\n",
      " |          If no point given, the curve will be rotated around origin.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Curve :\n",
      " |          returns a curve rotated at given angle along given point.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Curve, pi\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Curve((x, x), (x, 0, 1)).rotate(pi/2)\n",
      " |      Curve((-x, x), (x, 0, 1))\n",
      " |  \n",
      " |  scale(self, x=1, y=1, pt=None)\n",
      " |      Override GeometryEntity.scale since Curve is not made up of Points.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Curve :\n",
      " |          returns scaled curve.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Curve\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Curve((x, x), (x, 0, 1)).scale(2)\n",
      " |      Curve((2*x, x), (x, 0, 1))\n",
      " |  \n",
      " |  translate(self, x=0, y=0)\n",
      " |      Translate the Curve by (x, y).\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Curve :\n",
      " |          returns a translated curve.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Curve\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Curve((x, x), (x, 0, 1)).translate(1, 2)\n",
      " |      Curve((x + 1, x + 2), (x, 0, 1))\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, function, limits)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  ambient_dimension\n",
      " |      The dimension of the curve.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      int :\n",
      " |          the dimension of curve.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import t\n",
      " |      >>> from sympy import Curve\n",
      " |      >>> C = Curve((t, t**2), (t, 0, 2))\n",
      " |      >>> C.ambient_dimension\n",
      " |      2\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return a set of symbols other than the bound symbols used to\n",
      " |      parametrically define the Curve.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      set :\n",
      " |          Set of all non-parameterized symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import t, a\n",
      " |      >>> from sympy import Curve\n",
      " |      >>> Curve((t, t**2), (t, 0, 2)).free_symbols\n",
      " |      set()\n",
      " |      >>> Curve((t, t**2), (t, a, 2)).free_symbols\n",
      " |      {a}\n",
      " |  \n",
      " |  functions\n",
      " |      The functions specifying the curve.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      functions :\n",
      " |          list of parameterized coordinate functions.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import t\n",
      " |      >>> from sympy import Curve\n",
      " |      >>> C = Curve((t, t**2), (t, 0, 2))\n",
      " |      >>> C.functions\n",
      " |      (t, t**2)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      parameter\n",
      " |  \n",
      " |  length\n",
      " |      The curve length.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Curve\n",
      " |      >>> from sympy.abc import t\n",
      " |      >>> Curve((t, t), (t, 0, 1)).length\n",
      " |      sqrt(2)\n",
      " |  \n",
      " |  limits\n",
      " |      The limits for the curve.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      limits : tuple\n",
      " |          Contains parameter and lower and upper limits.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import t\n",
      " |      >>> from sympy import Curve\n",
      " |      >>> C = Curve([t, t**3], (t, -2, 2))\n",
      " |      >>> C.limits\n",
      " |      (t, -2, 2)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      plot_interval\n",
      " |  \n",
      " |  parameter\n",
      " |      The curve function variable.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Symbol :\n",
      " |          returns a bound symbol.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import t\n",
      " |      >>> from sympy import Curve\n",
      " |      >>> C = Curve([t, t**2], (t, 0, 2))\n",
      " |      >>> C.parameter\n",
      " |      t\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      functions\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.geometry.entity.GeometryEntity:\n",
      " |  \n",
      " |  __cmp__(self, other)\n",
      " |      Comparison of two GeometryEntities.\n",
      " |  \n",
      " |  __contains__(self, other)\n",
      " |      Subclasses should implement this method for anything more complex than equality.\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |      Returns a tuple that will be passed to __new__ on unpickling.\n",
      " |  \n",
      " |  __ne__(self, o)\n",
      " |      Test inequality of two geometrical entities.\n",
      " |  \n",
      " |  __radd__(self, a)\n",
      " |      Implementation of reverse add method.\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      String representation of a GeometryEntity that can be evaluated\n",
      " |      by sympy.\n",
      " |  \n",
      " |  __rmul__(self, a)\n",
      " |      Implementation of reverse multiplication method.\n",
      " |  \n",
      " |  __rsub__(self, a)\n",
      " |      Implementation of reverse subtraction method.\n",
      " |  \n",
      " |  __rtruediv__(self, a)\n",
      " |      Implementation of reverse division method.\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      String representation of a GeometryEntity.\n",
      " |  \n",
      " |  encloses(self, o)\n",
      " |      Return True if o is inside (not on or outside) the boundaries of self.\n",
      " |      \n",
      " |      The object will be decomposed into Points and individual Entities need\n",
      " |      only define an encloses_point method for their class.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.ellipse.Ellipse.encloses_point\n",
      " |      sympy.geometry.polygon.Polygon.encloses_point\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point, Polygon\n",
      " |      >>> t  = Polygon(*RegularPolygon(Point(0, 0), 1, 3).vertices)\n",
      " |      >>> t2 = Polygon(*RegularPolygon(Point(0, 0), 2, 3).vertices)\n",
      " |      >>> t2.encloses(t)\n",
      " |      True\n",
      " |      >>> t.encloses(t2)\n",
      " |      False\n",
      " |  \n",
      " |  equals(self, o)\n",
      " |  \n",
      " |  intersection(self, o)\n",
      " |      Returns a list of all of the intersections of self with o.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      An entity is not required to implement this method.\n",
      " |      \n",
      " |      If two different types of entities can intersect, the item with\n",
      " |      higher index in ordering_of_classes should implement\n",
      " |      intersections with anything having a lower index.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.util.intersection\n",
      " |  \n",
      " |  is_similar(self, other)\n",
      " |      Is this geometrical entity similar to another geometrical entity?\n",
      " |      \n",
      " |      Two entities are similar if a uniform scaling (enlarging or\n",
      " |      shrinking) of one of the entities will allow one to obtain the other.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This method is not intended to be used directly but rather\n",
      " |      through the `are_similar` function found in util.py.\n",
      " |      An entity is not required to implement this method.\n",
      " |      If two different types of entities can be similar, it is only\n",
      " |      required that one of them be able to determine this.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      scale\n",
      " |  \n",
      " |  parameter_value(self, other, t)\n",
      " |      Return the parameter corresponding to the given point.\n",
      " |      Evaluating an arbitrary point of the entity at this parameter\n",
      " |      value will return the given point.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Line, Point\n",
      " |      >>> from sympy.abc import t\n",
      " |      >>> a = Point(0, 0)\n",
      " |      >>> b = Point(2, 2)\n",
      " |      >>> Line(a, b).parameter_value((1, 1), t)\n",
      " |      {t: 1/2}\n",
      " |      >>> Line(a, b).arbitrary_point(t).subs(_)\n",
      " |      Point2D(1, 1)\n",
      " |  \n",
      " |  reflect(self, line)\n",
      " |      Reflects an object across a line.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      line: Line\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, sqrt, Line, RegularPolygon\n",
      " |      >>> l = Line((0, pi), slope=sqrt(2))\n",
      " |      >>> pent = RegularPolygon((1, 2), 1, 5)\n",
      " |      >>> rpent = pent.reflect(l)\n",
      " |      >>> rpent\n",
      " |      RegularPolygon(Point2D(-2*sqrt(2)*pi/3 - 1/3 + 4*sqrt(2)/3, 2/3 + 2*sqrt(2)/3 + 2*pi/3), -1, 5, -atan(2*sqrt(2)) + 3*pi/5)\n",
      " |      \n",
      " |      >>> from sympy import pi, Line, Circle, Point\n",
      " |      >>> l = Line((0, pi), slope=1)\n",
      " |      >>> circ = Circle(Point(0, 0), 5)\n",
      " |      >>> rcirc = circ.reflect(l)\n",
      " |      >>> rcirc\n",
      " |      Circle(Point2D(-pi, pi), -5)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.geometry.entity.GeometryEntity:\n",
      " |  \n",
      " |  bounds\n",
      " |      Return a tuple (xmin, ymin, xmax, ymax) representing the bounding\n",
      " |      rectangle for the geometric figure.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |  \n",
      " |  __pow__(self, exp)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  complement(self, universe)\n",
      " |      The complement of 'self' w.r.t the given universe.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(0, 1).complement(S.Reals)\n",
      " |      Union(Interval.open(-oo, 0), Interval.open(1, oo))\n",
      " |      \n",
      " |      >>> Interval(0, 1).complement(S.UniversalSet)\n",
      " |      Complement(UniversalSet, Interval(0, 1))\n",
      " |  \n",
      " |  contains(self, other)\n",
      " |      Returns a SymPy value indicating whether ``other`` is contained\n",
      " |      in ``self``: ``true`` if it is, ``false`` if it is not, else\n",
      " |      an unevaluated ``Contains`` expression (or, as in the case of\n",
      " |      ConditionSet and a union of FiniteSet/Intervals, an expression\n",
      " |      indicating the conditions for containment).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(0.5)\n",
      " |      True\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``in`` operator, but that\n",
      " |      will raise an error unless an affirmative true or false is not\n",
      " |      obtained.\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(x)\n",
      " |      (0 <= x) & (x <= 1)\n",
      " |      >>> x in Interval(0, 1)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      TypeError: did not evaluate to a bool: None\n",
      " |      \n",
      " |      The result of 'in' is a bool, not a SymPy value\n",
      " |      \n",
      " |      >>> 1 in Interval(0, 2)\n",
      " |      True\n",
      " |      >>> _ is S.true\n",
      " |      False\n",
      " |  \n",
      " |  intersect(self, other)\n",
      " |      Returns the intersection of 'self' and 'other'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      \n",
      " |      >>> Interval(1, 3).intersect(Interval(1, 2))\n",
      " |      Interval(1, 2)\n",
      " |      \n",
      " |      >>> from sympy import imageset, Lambda, symbols, S\n",
      " |      >>> n, m = symbols('n m')\n",
      " |      >>> a = imageset(Lambda(n, 2*n), S.Integers)\n",
      " |      >>> a.intersect(imageset(Lambda(m, 2*m + 1), S.Integers))\n",
      " |      EmptySet\n",
      " |  \n",
      " |  is_disjoint(self, other)\n",
      " |      Returns True if ``self`` and ``other`` are disjoint.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(1, 2))\n",
      " |      False\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(3, 4))\n",
      " |      True\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Disjoint_sets\n",
      " |  \n",
      " |  is_proper_subset(self, other)\n",
      " |      Returns True if ``self`` is a proper subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_proper_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_subset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_proper_superset(self, other)\n",
      " |      Returns True if ``self`` is a proper superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 0.5))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_subset(self, other)\n",
      " |      Returns True if ``self`` is a subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_subset(Interval(0, 1, left_open=True))\n",
      " |      False\n",
      " |  \n",
      " |  is_superset(self, other)\n",
      " |      Returns True if ``self`` is a superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_superset(Interval(0, 1))\n",
      " |      False\n",
      " |      >>> Interval(0, 1).is_superset(Interval(0, 1, left_open=True))\n",
      " |      True\n",
      " |  \n",
      " |  isdisjoint(self, other)\n",
      " |      Alias for :meth:`is_disjoint()`\n",
      " |  \n",
      " |  issubset(self, other)\n",
      " |      Alias for :meth:`is_subset()`\n",
      " |  \n",
      " |  issuperset(self, other)\n",
      " |      Alias for :meth:`is_superset()`\n",
      " |  \n",
      " |  powerset(self)\n",
      " |      Find the Power set of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import EmptySet, FiniteSet, Interval\n",
      " |      \n",
      " |      A power set of an empty set:\n",
      " |      \n",
      " |      >>> A = EmptySet\n",
      " |      >>> A.powerset()\n",
      " |      {EmptySet}\n",
      " |      \n",
      " |      A power set of a finite set:\n",
      " |      \n",
      " |      >>> A = FiniteSet(1, 2)\n",
      " |      >>> a, b, c = FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)\n",
      " |      >>> A.powerset() == FiniteSet(a, b, c, EmptySet)\n",
      " |      True\n",
      " |      \n",
      " |      A power set of an interval:\n",
      " |      \n",
      " |      >>> Interval(1, 2).powerset()\n",
      " |      PowerSet(Interval(1, 2))\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Power_set\n",
      " |  \n",
      " |  symmetric_difference(self, other)\n",
      " |      Returns symmetric difference of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(1, 3).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(3, oo))\n",
      " |      >>> Interval(1, 10).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(10, oo))\n",
      " |      \n",
      " |      >>> from sympy import S, EmptySet\n",
      " |      >>> S.Reals.symmetric_difference(EmptySet)\n",
      " |      Reals\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      .. [1] https://en.wikipedia.org/wiki/Symmetric_difference\n",
      " |  \n",
      " |  union(self, other)\n",
      " |      Returns the union of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``+`` operator:\n",
      " |      \n",
      " |      >>> from sympy import Interval, FiniteSet\n",
      " |      >>> Interval(0, 1).union(Interval(2, 3))\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(0, 1) + Interval(2, 3)\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(1, 2, True, True) + FiniteSet(2, 3)\n",
      " |      Union({3}, Interval.Lopen(1, 2))\n",
      " |      \n",
      " |      Similarly it is possible to use the ``-`` operator for set differences:\n",
      " |      \n",
      " |      >>> Interval(0, 2) - Interval(0, 1)\n",
      " |      Interval.Lopen(1, 2)\n",
      " |      >>> Interval(1, 3) - FiniteSet(2)\n",
      " |      Union(Interval.Ropen(1, 2), Interval.Lopen(2, 3))\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  boundary\n",
      " |      The boundary or frontier of a set.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A point x is on the boundary of a set S if\n",
      " |      \n",
      " |      1.  x is in the closure of S.\n",
      " |          I.e. Every neighborhood of x contains a point in S.\n",
      " |      2.  x is not in the interior of S.\n",
      " |          I.e. There does not exist an open set centered on x contained\n",
      " |          entirely within S.\n",
      " |      \n",
      " |      There are the points on the outer rim of S.  If S is open then these\n",
      " |      points need not actually be contained within S.\n",
      " |      \n",
      " |      For example, the boundary of an interval is its start and end points.\n",
      " |      This is true regardless of whether or not the interval is open.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).boundary\n",
      " |      {0, 1}\n",
      " |      >>> Interval(0, 1, True, False).boundary\n",
      " |      {0, 1}\n",
      " |  \n",
      " |  closure\n",
      " |      Property method which returns the closure of a set.\n",
      " |      The closure is defined as the union of the set itself and its\n",
      " |      boundary.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S, Interval\n",
      " |      >>> S.Reals.closure\n",
      " |      Reals\n",
      " |      >>> Interval(0, 1).closure\n",
      " |      Interval(0, 1)\n",
      " |  \n",
      " |  inf\n",
      " |      The infimum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).inf\n",
      " |      0\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).inf\n",
      " |      0\n",
      " |  \n",
      " |  interior\n",
      " |      Property method which returns the interior of a set.\n",
      " |      The interior of a set S consists all points of S that do not\n",
      " |      belong to the boundary of S.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).interior\n",
      " |      Interval.open(0, 1)\n",
      " |      >>> Interval(0, 1).boundary.interior\n",
      " |      EmptySet\n",
      " |  \n",
      " |  is_EmptySet\n",
      " |  \n",
      " |  is_closed\n",
      " |      A property method to check whether a set is closed.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is closed if its complement is an open set. The closedness of a\n",
      " |      subset of the reals is determined with respect to R and its standard\n",
      " |      topology.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_closed\n",
      " |      True\n",
      " |  \n",
      " |  is_open\n",
      " |      Property method to check whether a set is open.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is open if and only if it has an empty intersection with its\n",
      " |      boundary. In particular, a subset A of the reals is open if and only\n",
      " |      if each one of its points is contained in an open interval that is a\n",
      " |      subset of A.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S\n",
      " |      >>> S.Reals.is_open\n",
      " |      True\n",
      " |      >>> S.Rationals.is_open\n",
      " |      False\n",
      " |  \n",
      " |  kind\n",
      " |      The kind of a Set\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      Any :class:`Set` will have kind :class:`SetKind` which is\n",
      " |      parametrised by the kind of the elements of the set. For example\n",
      " |      most sets are sets of numbers and will have kind\n",
      " |      ``SetKind(NumberKind)``. If elements of sets are different in kind than\n",
      " |      their kind will ``SetKind(UndefinedKind)``. See\n",
      " |      :class:`sympy.core.kind.Kind` for an explanation of the kind system.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Matrix, FiniteSet, EmptySet, ProductSet, PowerSet\n",
      " |      \n",
      " |      >>> FiniteSet(Matrix([1, 2])).kind\n",
      " |      SetKind(MatrixKind(NumberKind))\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind\n",
      " |      SetKind(NumberKind)\n",
      " |      \n",
      " |      >>> EmptySet.kind\n",
      " |      SetKind()\n",
      " |      \n",
      " |      A :class:`sympy.sets.powerset.PowerSet` is a set of sets:\n",
      " |      \n",
      " |      >>> PowerSet({1, 2, 3}).kind\n",
      " |      SetKind(SetKind(NumberKind))\n",
      " |      \n",
      " |      A :class:`ProductSet` represents the set of tuples of elements of\n",
      " |      other sets. Its kind is :class:`sympy.core.containers.TupleKind`\n",
      " |      parametrised by the kinds of the elements of those sets:\n",
      " |      \n",
      " |      >>> p = ProductSet(FiniteSet(1, 2), FiniteSet(3, 4))\n",
      " |      >>> list(p)\n",
      " |      [(1, 3), (2, 3), (1, 4), (2, 4)]\n",
      " |      >>> p.kind\n",
      " |      SetKind(TupleKind(NumberKind, NumberKind))\n",
      " |      \n",
      " |      When all elements of the set do not have same kind, the kind\n",
      " |      will be returned as ``SetKind(UndefinedKind)``:\n",
      " |      \n",
      " |      >>> FiniteSet(0, Matrix([1, 2])).kind\n",
      " |      SetKind(UndefinedKind)\n",
      " |      \n",
      " |      The kind of the elements of a set are given by the ``element_kind``\n",
      " |      attribute of ``SetKind``:\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind.element_kind\n",
      " |      NumberKind\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      NumberKind\n",
      " |      sympy.core.kind.UndefinedKind\n",
      " |      sympy.core.containers.TupleKind\n",
      " |      MatrixKind\n",
      " |      sympy.matrices.expressions.sets.MatrixSet\n",
      " |      sympy.sets.conditionset.ConditionSet\n",
      " |      Rationals\n",
      " |      Naturals\n",
      " |      Integers\n",
      " |      sympy.sets.fancysets.ImageSet\n",
      " |      sympy.sets.fancysets.Range\n",
      " |      sympy.sets.fancysets.ComplexRegion\n",
      " |      sympy.sets.powerset.PowerSet\n",
      " |      sympy.sets.sets.ProductSet\n",
      " |      sympy.sets.sets.Interval\n",
      " |      sympy.sets.sets.Union\n",
      " |      sympy.sets.sets.Intersection\n",
      " |      sympy.sets.sets.Complement\n",
      " |      sympy.sets.sets.EmptySet\n",
      " |      sympy.sets.sets.UniversalSet\n",
      " |      sympy.sets.sets.FiniteSet\n",
      " |      sympy.sets.sets.SymmetricDifference\n",
      " |      sympy.sets.sets.DisjointUnion\n",
      " |  \n",
      " |  measure\n",
      " |      The (Lebesgue) measure of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).measure\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).measure\n",
      " |      2\n",
      " |  \n",
      " |  sup\n",
      " |      The supremum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).sup\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).sup\n",
      " |      3\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  is_Complement = None\n",
      " |  \n",
      " |  is_ComplexRegion = False\n",
      " |  \n",
      " |  is_FiniteSet = False\n",
      " |  \n",
      " |  is_Intersection = None\n",
      " |  \n",
      " |  is_Interval = False\n",
      " |  \n",
      " |  is_ProductSet = False\n",
      " |  \n",
      " |  is_Union = False\n",
      " |  \n",
      " |  is_UniversalSet = None\n",
      " |  \n",
      " |  is_empty = None\n",
      " |  \n",
      " |  is_finite_set = None\n",
      " |  \n",
      " |  is_interval = False\n",
      " |  \n",
      " |  is_iterable = False\n",
      " |  \n",
      " |  is_number = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      A stub to allow Basic args (like Tuple) to be skipped when computing\n",
      " |      the content and primitive components of an expression.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.expr.Expr.as_content_primitive\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace(self, rule)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  class_key() from sympy.core.assumptions.ManagedProperties\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.assumptions.ManagedProperties\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __annotations__ = {'_args': 'tuple[Basic, ...]', '_mhash': 'int | None...\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Curve)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 490,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Curve((t,2-t/2),(t,-oo,oo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 492,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1=Line(y-(2-x/2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 493,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x}{2} + y - 2$"
      ],
      "text/plain": [
       "x/2 + y - 2"
      ]
     },
     "execution_count": 493,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 497,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.abc import rho,theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 499,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=3*rho**2+(rho*sin(theta))**2-12\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 501,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\rho^{2} \\sin^{2}{\\left(\\theta \\right)} + 3 \\rho^{2} - 12$"
      ],
      "text/plain": [
       "rho**2*sin(theta)**2 + 3*rho**2 - 12"
      ]
     },
     "execution_count": 501,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 502,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 x^{2} + 3 y^{2} - 12 + \\frac{y^{2} \\left(x^{2} + y^{2}\\right)}{x^{2} \\cdot \\left(1 + \\frac{y^{2}}{x^{2}}\\right)}$"
      ],
      "text/plain": [
       "3*x**2 + 3*y**2 - 12 + y**2*(x**2 + y**2)/(x**2*(1 + y**2/x**2))"
      ]
     },
     "execution_count": 502,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs({rho:sqrt(x**2+y**2),theta:atan(y/x)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 503,
   "metadata": {},
   "outputs": [],
   "source": [
    "cur=simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 504,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 x^{2} + 4 y^{2} - 12$"
      ],
      "text/plain": [
       "3*x**2 + 4*y**2 - 12"
      ]
     },
     "execution_count": 504,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 505,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=symbols(\"a\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 506,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=Abs(x-a)+2*a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 507,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a + \\left|{a - x}\\right|$"
      ],
      "text/plain": [
       "2*a + Abs(a - x)"
      ]
     },
     "execution_count": 507,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 509,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[-1, 3\\right]$"
      ],
      "text/plain": [
       "Interval(-1, 3)"
      ]
     },
     "execution_count": 509,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(expr.subs(a,1)<=4,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 514,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr2=Piecewise((-(expr.subs(a,1)-2)/x,x<0),((expr.subs(a,1)-2)/x,True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 516,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x77d1b12af850>"
      ]
     },
     "execution_count": 516,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr2,(x,-10,10),ylim=(-3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2024压轴卷（T8联盟）（文科）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 573,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=solveset(2*x-x**2>=0,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 574,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[0, 2\\right]$"
      ],
      "text/plain": [
       "Interval(0, 2)"
      ]
     },
     "execution_count": 574,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 575,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=FiniteSet(*range(0,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 576,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{0, 1, 2, 3\\right\\}$"
      ],
      "text/plain": [
       "{0, 1, 2, 3}"
      ]
     },
     "execution_count": 576,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 577,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{3\\right\\}$"
      ],
      "text/plain": [
       "{3}"
      ]
     },
     "execution_count": 577,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(Reals-A)&B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 578,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(1 - i\\right) \\left(2 + i\\right)}{2}$"
      ],
      "text/plain": [
       "(1 - I)*(2 + I)/2"
      ]
     },
     "execution_count": 578,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2-I**3)/(1+I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 579,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3}{2} - \\frac{i}{2}$"
      ],
      "text/plain": [
       "3/2 - I/2"
      ]
     },
     "execution_count": 579,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nsimplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 580,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=exp(x)+a*x+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 581,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x + e^{x} + 1$"
      ],
      "text/plain": [
       "a*x + exp(x) + 1"
      ]
     },
     "execution_count": 581,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 582,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a + 2$"
      ],
      "text/plain": [
       "a + 2"
      ]
     },
     "execution_count": 582,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(expr,x).subs(x,ln(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 584,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x77d1b135dc40>"
      ]
     },
     "execution_count": 584,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr.subs(a,-2),(x,0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 585,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function plot_implicit in module sympy.plotting.plot_implicit:\n",
      "\n",
      "plot_implicit(expr, x_var=None, y_var=None, adaptive=True, depth=0, points=300, line_color='blue', show=True, **kwargs)\n",
      "    A plot function to plot implicit equations / inequalities.\n",
      "    \n",
      "    Arguments\n",
      "    =========\n",
      "    \n",
      "    - ``expr`` : The equation / inequality that is to be plotted.\n",
      "    - ``x_var`` (optional) : symbol to plot on x-axis or tuple giving symbol\n",
      "      and range as ``(symbol, xmin, xmax)``\n",
      "    - ``y_var`` (optional) : symbol to plot on y-axis or tuple giving symbol\n",
      "      and range as ``(symbol, ymin, ymax)``\n",
      "    \n",
      "    If neither ``x_var`` nor ``y_var`` are given then the free symbols in the\n",
      "    expression will be assigned in the order they are sorted.\n",
      "    \n",
      "    The following keyword arguments can also be used:\n",
      "    \n",
      "    - ``adaptive`` Boolean. The default value is set to True. It has to be\n",
      "        set to False if you want to use a mesh grid.\n",
      "    \n",
      "    - ``depth`` integer. The depth of recursion for adaptive mesh grid.\n",
      "        Default value is 0. Takes value in the range (0, 4).\n",
      "    \n",
      "    - ``points`` integer. The number of points if adaptive mesh grid is not\n",
      "        used. Default value is 300.\n",
      "    \n",
      "    - ``show`` Boolean. Default value is True. If set to False, the plot will\n",
      "        not be shown. See ``Plot`` for further information.\n",
      "    \n",
      "    - ``title`` string. The title for the plot.\n",
      "    \n",
      "    - ``xlabel`` string. The label for the x-axis\n",
      "    \n",
      "    - ``ylabel`` string. The label for the y-axis\n",
      "    \n",
      "    Aesthetics options:\n",
      "    \n",
      "    - ``line_color``: float or string. Specifies the color for the plot.\n",
      "        See ``Plot`` to see how to set color for the plots.\n",
      "        Default value is \"Blue\"\n",
      "    \n",
      "    plot_implicit, by default, uses interval arithmetic to plot functions. If\n",
      "    the expression cannot be plotted using interval arithmetic, it defaults to\n",
      "    a generating a contour using a mesh grid of fixed number of points. By\n",
      "    setting adaptive to False, you can force plot_implicit to use the mesh\n",
      "    grid. The mesh grid method can be effective when adaptive plotting using\n",
      "    interval arithmetic, fails to plot with small line width.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    Plot expressions:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: reset\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> from sympy import plot_implicit, symbols, Eq, And\n",
      "        >>> x, y = symbols('x y')\n",
      "    \n",
      "    Without any ranges for the symbols in the expression:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p1 = plot_implicit(Eq(x**2 + y**2, 5))\n",
      "    \n",
      "    With the range for the symbols:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p2 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 3), (x, -3, 3), (y, -3, 3))\n",
      "    \n",
      "    With depth of recursion as argument:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p3 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 5), (x, -4, 4), (y, -4, 4), depth = 2)\n",
      "    \n",
      "    Using mesh grid and not using adaptive meshing:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p4 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2),\n",
      "        ...     adaptive=False)\n",
      "    \n",
      "    Using mesh grid without using adaptive meshing with number of points\n",
      "    specified:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p5 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2),\n",
      "        ...     adaptive=False, points=400)\n",
      "    \n",
      "    Plotting regions:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p6 = plot_implicit(y > x**2)\n",
      "    \n",
      "    Plotting Using boolean conjunctions:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p7 = plot_implicit(And(y > x, y > -x))\n",
      "    \n",
      "    When plotting an expression with a single variable (y - 1, for example),\n",
      "    specify the x or the y variable explicitly:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p8 = plot_implicit(y - 1, y_var=y)\n",
      "        >>> p9 = plot_implicit(x - 1, x_var=x)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plot_implicit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 587,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x77d1c6872c70>"
      ]
     },
     "execution_count": 587,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_implicit(And(x-y-1<=0,x+y-4<=0,2*x-y>=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 588,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,q=symbols(\"a,q\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 614,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 614,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a>0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 615,
   "metadata": {},
   "outputs": [],
   "source": [
    "an=SeqFormula(a*q**(n-1),(n,1,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 616,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[a, a q, a q^{2}, a q^{3}, \\ldots\\right]$"
      ],
      "text/plain": [
       "SeqFormula(a*q**(n - 1), (n, 1, 6))"
      ]
     },
     "execution_count": 616,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "an"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 617,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a$"
      ],
      "text/plain": [
       "a"
      ]
     },
     "execution_count": 617,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "an[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 619,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( -55774 - 4342 \\sqrt{165}, \\  - \\frac{13}{2} + \\frac{\\sqrt{165}}{2}\\right), \\left( -55774 + 4342 \\sqrt{165}, \\  - \\frac{13}{2} - \\frac{\\sqrt{165}}{2}\\right), \\left( 28318 - 7854 \\sqrt{13}, \\  \\frac{3 \\sqrt{13}}{2} + \\frac{11}{2}\\right), \\left( 7854 \\sqrt{13} + 28318, \\  \\frac{11}{2} - \\frac{3 \\sqrt{13}}{2}\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(-55774 - 4342*sqrt(165), -13/2 + sqrt(165)/2), (-55774 + 4342*sqrt(165), -13/2 - sqrt(165)/2), (28318 - 7854*sqrt(13), 3*sqrt(13)/2 + 11/2), (7854*sqrt(13) + 28318, 11/2 - 3*sqrt(13)/2)}"
      ]
     },
     "execution_count": 619,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nonlinsolve([sum(an[3:6])-48,1/an[3]+1/an[4]+1/an[5]-3],[a,q],Interval.open(0,oo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 620,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,q=list(_)[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 621,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 7854 \\sqrt{13} + 28318$"
      ],
      "text/plain": [
       "7854*sqrt(13) + 28318"
      ]
     },
     "execution_count": 621,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 624,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{11}{2} - \\frac{3 \\sqrt{13}}{2}$"
      ],
      "text/plain": [
       "11/2 - 3*sqrt(13)/2"
      ]
     },
     "execution_count": 624,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 626,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 626,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q>0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 627,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(\\frac{11}{2} - \\frac{3 \\sqrt{13}}{2}\\right)^{4} \\cdot \\left(7854 \\sqrt{13} + 28318\\right)$"
      ],
      "text/plain": [
       "(11/2 - 3*sqrt(13)/2)**4*(7854*sqrt(13) + 28318)"
      ]
     },
     "execution_count": 627,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a*q**4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 628,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4$"
      ],
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 628,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nsimplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 631,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Data([m,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 632,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[m, 1]"
      ]
     },
     "execution_count": 632,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 633,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Data([-2,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 634,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-2, 0]"
      ]
     },
     "execution_count": 634,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 635,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle m \\left(m - 2\\right) + 1$"
      ],
      "text/plain": [
       "m*(m - 2) + 1"
      ]
     },
     "execution_count": 635,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(A*(A+B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 637,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{1\\right\\}$"
      ],
      "text/plain": [
       "{1}"
      ]
     },
     "execution_count": 637,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,m,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 638,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=Circle(Point(0,0),sqrt(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 639,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} + y^{2} - 5$"
      ],
      "text/plain": [
       "x**2 + y**2 - 5"
      ]
     },
     "execution_count": 639,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 640,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(x-2*y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 642,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B=Intersection(l,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 643,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 2 x + 4 y$"
      ],
      "text/plain": [
       "-2*x + 4*y"
      ]
     },
     "execution_count": 643,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line(A,B).equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 644,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(-2, -1\\right)$"
      ],
      "text/plain": [
       "Point2D(-2, -1)"
      ]
     },
     "execution_count": 644,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 645,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(2, 1\\right)$"
      ],
      "text/plain": [
       "Point2D(2, 1)"
      ]
     },
     "execution_count": 645,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 646,
   "metadata": {},
   "outputs": [],
   "source": [
    "m=Matrix([[80,20],[60,40]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 647,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}80 & 20\\\\60 & 40\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[80, 20],\n",
       "[60, 40]])"
      ]
     },
     "execution_count": 647,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 648,
   "metadata": {},
   "outputs": [],
   "source": [
    "chi=ChiSquaredTest(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 649,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}80 & 20 & 100\\\\60 & 40 & 100\\\\140 & 60 & 200\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[ 80, 20, 100],\n",
       "[ 60, 40, 100],\n",
       "[140, 60, 200]])"
      ]
     },
     "execution_count": 649,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chi.expand_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 657,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{200}{21}$"
      ],
      "text/plain": [
       "200/21"
      ]
     },
     "execution_count": 657,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chi.chi_squared_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 658,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 9.52380952380952$"
      ],
      "text/plain": [
       "9.52380952380952"
      ]
     },
     "execution_count": 658,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 654,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 655,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.00202823114845208$"
      ],
      "text/plain": [
       "0.00202823114845208"
      ]
     },
     "execution_count": 655,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(chi.error_probability)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 656,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.07225085582223\n",
      "2.70554345409542\n",
      "3.84145882069412\n",
      "5.02388618731489\n",
      "6.63489660102121\n"
     ]
    }
   ],
   "source": [
    "for i in [0.15,0.1,0.05,0.025,0.01]:\n",
    "    print(chi_squared_of_error_probability(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 659,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(x-1)*(ln(x)-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 660,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(x - 1\\right) \\left(\\log{\\left(x \\right)} - 1\\right)$"
      ],
      "text/plain": [
       "(x - 1)*(log(x) - 1)"
      ]
     },
     "execution_count": 660,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 661,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle y = 1 - x$"
      ],
      "text/plain": [
       "Eq(y, 1 - x)"
      ]
     },
     "execution_count": 661,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_tangent(expr,x,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 663,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x77d1b0f07280>"
      ]
     },
     "execution_count": 663,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,0.2,4),ylim=(-3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 664,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x \\log{\\left(x \\right)} - 1}{x}$"
      ],
      "text/plain": [
       "(x*log(x) - 1)/x"
      ]
     },
     "execution_count": 664,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 665,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1012}{2025}$"
      ],
      "text/plain": [
       "1012/2025"
      ]
     },
     "execution_count": 665,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(1/(2*n*(n+1)),(n,1,2024))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 吉安高一下学期期末质量检测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Data([2-m,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2 - m, 4]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Data([1,8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 34 - m$"
      ],
      "text/plain": [
       "34 - m"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(A*B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{34\\right\\}$"
      ],
      "text/plain": [
       "{34}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,m,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "z=(2+I)/(I-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{1}{2} + \\frac{3 i}{2}$"
      ],
      "text/plain": [
       "-1/2 + 3*I/2"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nsimplify(conjugate(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.frustum_cone\n",
    "from geometry3D.frustum_cone import FrustumCone"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "frucone=FrustumCone(2,4,generatrix=6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 \\sqrt{2}$"
      ],
      "text/plain": [
       "4*sqrt(2)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frucone.height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{112 \\sqrt{2} \\pi}{3}$"
      ],
      "text/plain": [
       "112*sqrt(2)*pi/3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frucone.volume"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{2}}{2}$"
      ],
      "text/plain": [
       "sqrt(2)/2"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1/sin(pi/4)*sin(pi/6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "eq=Eq(sin(2*x)/(1-cos(2*x)),-1/S(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sin{\\left(2 x \\right)}}{1 - \\cos{\\left(2 x \\right)}} = - \\frac{1}{3}$"
      ],
      "text/plain": [
       "Eq(sin(2*x)/(1 - cos(2*x)), -1/3)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\sin{\\left(x \\right)} \\cos{\\left(x \\right)}}{2 - 2 \\cos^{2}{\\left(x \\right)}} = - \\frac{1}{3}$"
      ],
      "text/plain": [
       "Eq(2*sin(x)*cos(x)/(2 - 2*cos(x)**2), -1/3)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_trig(eq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{4 \\cdot \\left(1 - \\tan^{2}{\\left(\\frac{x}{2} \\right)}\\right) \\tan{\\left(\\frac{x}{2} \\right)}}{\\left(- \\frac{2 \\left(1 - \\tan^{2}{\\left(\\frac{x}{2} \\right)}\\right)^{2}}{\\left(\\tan^{2}{\\left(\\frac{x}{2} \\right)} + 1\\right)^{2}} + 2\\right) \\left(\\tan^{2}{\\left(\\frac{x}{2} \\right)} + 1\\right)^{2}} = - \\frac{1}{3}$"
      ],
      "text/plain": [
       "Eq(4*(1 - tan(x/2)**2)*tan(x/2)/((-2*(1 - tan(x/2)**2)**2/(tan(x/2)**2 + 1)**2 + 2)*(tan(x/2)**2 + 1)**2), -1/3)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.rewrite(tan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\tan{\\left(\\frac{x}{2} \\right)}}{2} - \\frac{1}{2 \\tan{\\left(\\frac{x}{2} \\right)}} = \\frac{1}{3}$"
      ],
      "text/plain": [
       "Eq(tan(x/2)/2 - 1/(2*tan(x/2)), 1/3)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{1}{3} - \\frac{\\sqrt{10}}{3}, \\frac{1}{3} + \\frac{\\sqrt{10}}{3}\\right\\}$"
      ],
      "text/plain": [
       "{1/3 - sqrt(10)/3, 1/3 + sqrt(10)/3}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,tan(x/2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.9^{x} > \\frac{1}{4}$"
      ],
      "text/plain": [
       "0.9**x > 1/4"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0.9)**x>1/S(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{1, 2, \\ldots, 13\\right\\}$"
      ],
      "text/plain": [
       "Range(1, 14, 1)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,x,Naturals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.477121254719662$"
      ],
      "text/plain": [
       "0.477121254719662"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(log(3,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.301029995663981$"
      ],
      "text/plain": [
       "0.301029995663981"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(log(2,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 13.1576269579212$"
      ],
      "text/plain": [
       "13.1576269579212"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-log(4.0,10)/log(0.9,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13.086956521739118"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-0.602/(0.954-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.abc import omega"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=lambda x:sin(omega*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "g=lambda x:cos(omega*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sin{\\left(\\omega \\cos{\\left(\\omega x \\right)} \\right)}$"
      ],
      "text/plain": [
       "sin(omega*cos(omega*x))"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(g(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_is_odd(_,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport function_calculator_package.utils \n",
    "from function_calculator_package.utils import function_is_odd,function_is_even\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_is_even(g(f(x)),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=f(g(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sin{\\left(\\omega \\cos{\\left(\\omega x \\right)} \\right)}$"
      ],
      "text/plain": [
       "sin(omega*cos(omega*x))"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7bb67edf6490>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(check.subs(omega,1),(x,0,pi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a^{2} + 4 a b + 4 b^{2}$"
      ],
      "text/plain": [
       "a**2 + 4*a*b + 4*b**2"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((a+2*b)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "r=symbols(\"r\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "h=sqrt(12)*(1-r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\sqrt{3} \\cdot \\left(1 - r\\right)$"
      ],
      "text/plain": [
       "2*sqrt(3)*(1 - r)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.sphere\n",
    "from geometry3D.sphere import Sphere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "sphere=Sphere(Point(0,0,0),sqrt((h/2)**2+r**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{4 \\pi \\left(r^{2} + 3 \\left(1 - r\\right)^{2}\\right)^{\\frac{3}{2}}}{3}$"
      ],
      "text/plain": [
       "4*pi*(r**2 + 3*(1 - r)**2)**(3/2)/3"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sphere.volume"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle r^{2} + 3 \\left(1 - r\\right)^{2}$"
      ],
      "text/plain": [
       "r**2 + 3*(1 - r)**2"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sphere.radius**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 \\left(x - \\frac{3}{4}\\right)^{2} + \\frac{3}{4}$"
      ],
      "text/plain": [
       "4*(x - 3/4)**2 + 3/4"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "QuadraticFunction(_,x=r).symmetry_equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\frac{\\sqrt{3} \\pi}{2}, 4 \\sqrt{3} \\pi\\right)$"
      ],
      "text/plain": [
       "Interval.Ropen(sqrt(3)*pi/2, 4*sqrt(3)*pi)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range(_,r,Interval.open(0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "m=symbols(\"m\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "z=(m**2+m-6)+(m**2-m-2)*I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle m^{2} + m + i \\left(m^{2} - m - 2\\right) - 6$"
      ],
      "text/plain": [
       "m**2 + m + I*(m**2 - m - 2) - 6"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__abs__',\n",
       " '__add__',\n",
       " '__annotations__',\n",
       " '__class__',\n",
       " '__complex__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__divmod__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__float__',\n",
       " '__floordiv__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getnewargs__',\n",
       " '__getstate__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__int__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__module__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__neg__',\n",
       " '__new__',\n",
       " '__pos__',\n",
       " '__pow__',\n",
       " '__radd__',\n",
       " '__rdivmod__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rfloordiv__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__round__',\n",
       " '__rpow__',\n",
       " '__rsub__',\n",
       " '__rtruediv__',\n",
       " '__setattr__',\n",
       " '__setstate__',\n",
       " '__sizeof__',\n",
       " '__slots__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__sympy__',\n",
       " '__truediv__',\n",
       " '__trunc__',\n",
       " '_add_handler',\n",
       " '_args',\n",
       " '_args_type',\n",
       " '_assumptions',\n",
       " '_combine_inverse',\n",
       " '_compare_pretty',\n",
       " '_constructor_postprocessor_mapping',\n",
       " '_diff_wrt',\n",
       " '_do_eq_sympify',\n",
       " '_eval_adjoint',\n",
       " '_eval_as_leading_term',\n",
       " '_eval_conjugate',\n",
       " '_eval_derivative',\n",
       " '_eval_derivative_matrix_lines',\n",
       " '_eval_derivative_n_times',\n",
       " '_eval_difference_delta',\n",
       " '_eval_evalf',\n",
       " '_eval_expand_complex',\n",
       " '_eval_interval',\n",
       " '_eval_is_algebraic',\n",
       " '_eval_is_algebraic_expr',\n",
       " '_eval_is_antihermitian',\n",
       " '_eval_is_commutative',\n",
       " '_eval_is_complex',\n",
       " '_eval_is_extended_negative',\n",
       " '_eval_is_extended_nonnegative',\n",
       " '_eval_is_extended_nonpositive',\n",
       " '_eval_is_extended_positive',\n",
       " '_eval_is_extended_positive_negative',\n",
       " '_eval_is_extended_real',\n",
       " '_eval_is_finite',\n",
       " '_eval_is_hermitian',\n",
       " '_eval_is_imaginary',\n",
       " '_eval_is_infinite',\n",
       " '_eval_is_integer',\n",
       " '_eval_is_irrational',\n",
       " '_eval_is_meromorphic',\n",
       " '_eval_is_odd',\n",
       " '_eval_is_polynomial',\n",
       " '_eval_is_rational',\n",
       " '_eval_is_rational_function',\n",
       " '_eval_is_real',\n",
       " '_eval_is_zero',\n",
       " '_eval_lseries',\n",
       " '_eval_nseries',\n",
       " '_eval_power',\n",
       " '_eval_rewrite',\n",
       " '_eval_subs',\n",
       " '_eval_transpose',\n",
       " '_evalf',\n",
       " '_exec_constructor_postprocessors',\n",
       " '_expand_hint',\n",
       " '_explicit_class_assumptions',\n",
       " '_from_args',\n",
       " '_from_mpmath',\n",
       " '_has',\n",
       " '_has_matcher',\n",
       " '_hashable_content',\n",
       " '_matches_commutative',\n",
       " '_matches_simple',\n",
       " '_mhash',\n",
       " '_mpc_',\n",
       " '_mul_handler',\n",
       " '_new_rawargs',\n",
       " '_op_priority',\n",
       " '_parse_order',\n",
       " '_pow',\n",
       " '_prop_handler',\n",
       " '_random',\n",
       " '_recursive_call',\n",
       " '_repr_disabled',\n",
       " '_repr_latex_',\n",
       " '_repr_png_',\n",
       " '_repr_svg_',\n",
       " '_rewrite',\n",
       " '_sage_',\n",
       " '_sorted_args',\n",
       " '_subs',\n",
       " '_to_mpmath',\n",
       " '_xreplace',\n",
       " 'adjoint',\n",
       " 'apart',\n",
       " 'args',\n",
       " 'args_cnc',\n",
       " 'as_base_exp',\n",
       " 'as_coeff_Add',\n",
       " 'as_coeff_Mul',\n",
       " 'as_coeff_add',\n",
       " 'as_coeff_exponent',\n",
       " 'as_coeff_mul',\n",
       " 'as_coefficient',\n",
       " 'as_coefficients_dict',\n",
       " 'as_content_primitive',\n",
       " 'as_dummy',\n",
       " 'as_expr',\n",
       " 'as_independent',\n",
       " 'as_leading_term',\n",
       " 'as_numer_denom',\n",
       " 'as_ordered_factors',\n",
       " 'as_ordered_terms',\n",
       " 'as_poly',\n",
       " 'as_powers_dict',\n",
       " 'as_real_imag',\n",
       " 'as_terms',\n",
       " 'as_two_terms',\n",
       " 'aseries',\n",
       " 'assumptions0',\n",
       " 'atoms',\n",
       " 'cancel',\n",
       " 'canonical_variables',\n",
       " 'class_key',\n",
       " 'coeff',\n",
       " 'collect',\n",
       " 'combsimp',\n",
       " 'compare',\n",
       " 'compute_leading_term',\n",
       " 'conjugate',\n",
       " 'copy',\n",
       " 'could_extract_minus_sign',\n",
       " 'count',\n",
       " 'count_ops',\n",
       " 'default_assumptions',\n",
       " 'diff',\n",
       " 'dir',\n",
       " 'doit',\n",
       " 'dummy_eq',\n",
       " 'equals',\n",
       " 'evalf',\n",
       " 'expand',\n",
       " 'expr_free_symbols',\n",
       " 'extract_additively',\n",
       " 'extract_branch_factor',\n",
       " 'extract_leading_order',\n",
       " 'extract_multiplicatively',\n",
       " 'factor',\n",
       " 'find',\n",
       " 'flatten',\n",
       " 'fourier_series',\n",
       " 'fps',\n",
       " 'free_symbols',\n",
       " 'fromiter',\n",
       " 'func',\n",
       " 'gammasimp',\n",
       " 'getO',\n",
       " 'getn',\n",
       " 'has',\n",
       " 'has_free',\n",
       " 'identity',\n",
       " 'integrate',\n",
       " 'invert',\n",
       " 'is_Add',\n",
       " 'is_AlgebraicNumber',\n",
       " 'is_Atom',\n",
       " 'is_Boolean',\n",
       " 'is_Derivative',\n",
       " 'is_Dummy',\n",
       " 'is_Equality',\n",
       " 'is_Float',\n",
       " 'is_Function',\n",
       " 'is_Indexed',\n",
       " 'is_Integer',\n",
       " 'is_MatAdd',\n",
       " 'is_MatMul',\n",
       " 'is_Matrix',\n",
       " 'is_Mul',\n",
       " 'is_Not',\n",
       " 'is_Number',\n",
       " 'is_NumberSymbol',\n",
       " 'is_Order',\n",
       " 'is_Piecewise',\n",
       " 'is_Point',\n",
       " 'is_Poly',\n",
       " 'is_Pow',\n",
       " 'is_Rational',\n",
       " 'is_Relational',\n",
       " 'is_Symbol',\n",
       " 'is_Vector',\n",
       " 'is_Wild',\n",
       " 'is_algebraic',\n",
       " 'is_algebraic_expr',\n",
       " 'is_antihermitian',\n",
       " 'is_commutative',\n",
       " 'is_comparable',\n",
       " 'is_complex',\n",
       " 'is_composite',\n",
       " 'is_constant',\n",
       " 'is_even',\n",
       " 'is_extended_negative',\n",
       " 'is_extended_nonnegative',\n",
       " 'is_extended_nonpositive',\n",
       " 'is_extended_nonzero',\n",
       " 'is_extended_positive',\n",
       " 'is_extended_real',\n",
       " 'is_finite',\n",
       " 'is_hermitian',\n",
       " 'is_hypergeometric',\n",
       " 'is_imaginary',\n",
       " 'is_infinite',\n",
       " 'is_integer',\n",
       " 'is_irrational',\n",
       " 'is_meromorphic',\n",
       " 'is_negative',\n",
       " 'is_noninteger',\n",
       " 'is_nonnegative',\n",
       " 'is_nonpositive',\n",
       " 'is_nonzero',\n",
       " 'is_number',\n",
       " 'is_odd',\n",
       " 'is_polar',\n",
       " 'is_polynomial',\n",
       " 'is_positive',\n",
       " 'is_prime',\n",
       " 'is_rational',\n",
       " 'is_rational_function',\n",
       " 'is_real',\n",
       " 'is_scalar',\n",
       " 'is_symbol',\n",
       " 'is_transcendental',\n",
       " 'is_zero',\n",
       " 'kind',\n",
       " 'leadterm',\n",
       " 'limit',\n",
       " 'lseries',\n",
       " 'make_args',\n",
       " 'match',\n",
       " 'matches',\n",
       " 'n',\n",
       " 'normal',\n",
       " 'nseries',\n",
       " 'nsimplify',\n",
       " 'powsimp',\n",
       " 'primitive',\n",
       " 'radsimp',\n",
       " 'ratsimp',\n",
       " 'rcall',\n",
       " 'refine',\n",
       " 'removeO',\n",
       " 'replace',\n",
       " 'rewrite',\n",
       " 'round',\n",
       " 'separate',\n",
       " 'series',\n",
       " 'simplify',\n",
       " 'sort_key',\n",
       " 'subs',\n",
       " 'taylor_term',\n",
       " 'together',\n",
       " 'transpose',\n",
       " 'trigsimp',\n",
       " 'xreplace']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-1, 2\\right\\}$"
      ],
      "text/plain": [
       "{-1, 2}"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(z.as_real_imag()[1],m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3$"
      ],
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Abs(z.subs(m,2)-3*I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=re(z)-im(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 m - 4$"
      ],
      "text/plain": [
       "2*m - 4"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{2\\right\\}$"
      ],
      "text/plain": [
       "{2}"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(expr,m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(m^{2} + m - i \\left(m^{2} - m - 2\\right) - 6 + i\\right) \\left(m^{2} + m + i \\left(m^{2} - m - 2\\right) - 5 - 2 i\\right)$"
      ],
      "text/plain": [
       "(m**2 + m - I*(m**2 - m - 2) - 6 + I)*(m**2 + m + I*(m**2 - m - 2) - 5 - 2*I)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(z+1-2*I)*(conjugate(z)+I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle i \\left(1 - 2 i\\right)$"
      ],
      "text/plain": [
       "I*(1 - 2*I)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.subs(m,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 + i$"
      ],
      "text/plain": [
       "2 + I"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nsimplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=sin(x-y)*sin(x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sin{\\left(x - y \\right)} \\sin{\\left(x + y \\right)}$"
      ],
      "text/plain": [
       "sin(x - y)*sin(x + y)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(\\sin{\\left(x \\right)} \\cos{\\left(y \\right)} - \\sin{\\left(y \\right)} \\cos{\\left(x \\right)}\\right) \\left(\\sin{\\left(x \\right)} \\cos{\\left(y \\right)} + \\sin{\\left(y \\right)} \\cos{\\left(x \\right)}\\right)$"
      ],
      "text/plain": [
       "(sin(x)*cos(y) - sin(y)*cos(x))*(sin(x)*cos(y) + sin(y)*cos(x))"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_trig(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\cos{\\left(2 x \\right)}}{2} + \\frac{\\cos{\\left(2 y \\right)}}{2}$"
      ],
      "text/plain": [
       "-cos(2*x)/2 + cos(2*y)/2"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expand(_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\sin^{2}{\\left(x + \\frac{\\pi}{2} \\right)} + \\sin^{2}{\\left(y + \\frac{\\pi}{2} \\right)}$"
      ],
      "text/plain": [
       "-sin(x + pi/2)**2 + sin(y + pi/2)**2"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_trig(_).rewrite(sin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "tri=Triangle(sss=(1,sqrt(3),sqrt(6)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg xmlns=\"http://www.w3.org/2000/svg\"\n",
       "            xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n",
       "            width=\"100.0\" height=\"100.0\" viewBox=\"-0.200000000000000 -0.200000000000000 2.40000000000000 1.81421356237310\"\n",
       "            preserveAspectRatio=\"xMinYMin meet\">\n",
       "            <defs>\n",
       "                <marker id=\"markerCircle\" markerWidth=\"8\" markerHeight=\"8\"\n",
       "                    refx=\"5\" refy=\"5\" markerUnits=\"strokeWidth\">\n",
       "                    <circle cx=\"5\" cy=\"5\" r=\"1.5\" style=\"stroke: none; fill:#000000;\"/>\n",
       "                </marker>\n",
       "                <marker id=\"markerArrow\" markerWidth=\"13\" markerHeight=\"13\" refx=\"2\" refy=\"4\"\n",
       "                       orient=\"auto\" markerUnits=\"strokeWidth\">\n",
       "                    <path d=\"M2,2 L2,6 L6,4\" style=\"fill: #000000;\" />\n",
       "                </marker>\n",
       "                <marker id=\"markerReverseArrow\" markerWidth=\"13\" markerHeight=\"13\" refx=\"6\" refy=\"4\"\n",
       "                       orient=\"auto\" markerUnits=\"strokeWidth\">\n",
       "                    <path d=\"M6,2 L6,6 L2,4\" style=\"fill: #000000;\" />\n",
       "                </marker>\n",
       "            </defs><g transform=\"matrix(1,0,0,-1,0,1.41421356237310)\"><path fill-rule=\"evenodd\" fill=\"#66cc99\" stroke=\"#555555\" stroke-width=\"0.0480000000000000\" opacity=\"0.6\" d=\"M 0,0 L 1.00000000000000,0 L 2.00000000000000,1.41421356237310 z\" /></g></svg>"
      ],
      "text/latex": [
       "$\\displaystyle \\operatorname{Triangle}\\left(\\operatorname{Point2D}\\left(0, 0\\right), \\operatorname{Point2D}\\left(1, 0\\right), \\operatorname{Point2D}\\left(2, \\sqrt{2}\\right)\\right)$"
      ],
      "text/plain": [
       "Triangle(Point2D(0, 0), Point2D(1, 0), Point2D(2, sqrt(2)))"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(- \\frac{\\sqrt{3}}{3} \\right)}$"
      ],
      "text/plain": [
       "acos(-sqrt(3)/3)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tri.angles[Point(1,0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_f=sin(2*x+pi/6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sin{\\left(2 x + \\frac{\\pi}{6} \\right)}$"
      ],
      "text/plain": [
       "sin(2*x + pi/6)"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[- \\frac{1}{2}, 1\\right]$"
      ],
      "text/plain": [
       "Interval(-1/2, 1)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range(expr_f,x,Interval(0,pi/2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_g=cos(x)**2+2*a*sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a \\sin{\\left(x \\right)} + \\cos^{2}{\\left(x \\right)}$"
      ],
      "text/plain": [
       "2*a*sin(x) + cos(x)**2"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a \\sin{\\left(x \\right)} - \\sin^{2}{\\left(x \\right)} + 1$"
      ],
      "text/plain": [
       "2*a*sin(x) - sin(x)**2 + 1"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_g.subs(cos(x)**2,1-sin(x)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_g1=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a \\sin{\\left(x \\right)} - \\sin^{2}{\\left(x \\right)} + 1$"
      ],
      "text/plain": [
       "2*a*sin(x) - sin(x)**2 + 1"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_g1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[-1, 1\\right]$"
      ],
      "text/plain": [
       "Interval(-1, 1)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range(sin(x),x,Interval(-2*pi/3,pi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a t - t^{2} - 3 < 0$"
      ],
      "text/plain": [
       "2*a*t - t**2 - 3 < 0"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_g1.subs(sin(x),t)-4<0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=(t**2+3)/(2*t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{t^{2} + 3}{2 t}$"
      ],
      "text/plain": [
       "(t**2 + 3)/(2*t)"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[2, \\infty\\right)$"
      ],
      "text/plain": [
       "Interval(2, oo)"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range(check,t,Interval.Lopen(0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, -2\\right]$"
      ],
      "text/plain": [
       "Interval(-oo, -2)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range(check,t,Interval.Ropen(-1,0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=a*n**2+b*n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a n^{2} + b n$"
      ],
      "text/plain": [
       "a*n**2 + b*n"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a + b$"
      ],
      "text/plain": [
       "a + b"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(n,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a n^{2} - a \\left(n - 1\\right)^{2} + b n - b \\left(n - 1\\right)$"
      ],
      "text/plain": [
       "a*n**2 - a*(n - 1)**2 + b*n - b*(n - 1)"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr-expr.subs(n,n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a n - a + b$"
      ],
      "text/plain": [
       "2*a*n - a + b"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 证明直角三角形斜边上中线等于直角边的一半"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 先构造一个直角三角形"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 输入三个点"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=Point(0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(0, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(0, 0)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 程序原因，定义两个大于零的符号变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y=symbols(\"x,y\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x>0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y>0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(x,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(x, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(x, 0)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(0,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(0, y\\right)$"
      ],
      "text/plain": [
       "Point2D(0, y)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义一个直角三角形"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 三点定义一个三角形"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "tri1=Triangle(C,A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Triangle}\\left(\\operatorname{Point2D}\\left(0, 0\\right), \\operatorname{Point2D}\\left(x, 0\\right), \\operatorname{Point2D}\\left(0, y\\right)\\right)$"
      ],
      "text/plain": [
       "Triangle(Point2D(0, 0), Point2D(x, 0), Point2D(0, y))"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tri1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 用角边角定义一个三角形"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "tri2=Triangle(sas=(y,90,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Triangle}\\left(\\operatorname{Point2D}\\left(0, 0\\right), \\operatorname{Point2D}\\left(x, 0\\right), \\operatorname{Point2D}\\left(0, y\\right)\\right)$"
      ],
      "text/plain": [
       "Triangle(Point2D(0, 0), Point2D(x, 0), Point2D(0, y))"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tri2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设点D为斜边的中点"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=(A+B)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{x}{2}, \\frac{y}{2}\\right)$"
      ],
      "text/plain": [
       "Point2D(x/2, y/2)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 求点A，B的距离的一半是多少"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{x^{2} + y^{2}}}{2}$"
      ],
      "text/plain": [
       "sqrt(x**2 + y**2)/2"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.distance(B)/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 求点D到点C的距离"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{\\frac{x^{2}}{4} + \\frac{y^{2}}{4}}$"
      ],
      "text/plain": [
       "sqrt(x**2/4 + y**2/4)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D.distance(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问计算机两者是否相等"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eq(A.distance(B)/2,D.distance(C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 尝试使用用中垂线法证明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 过点D做点B，C的垂线,并求他们的焦点E"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 定义线段B，C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "BC=Segment(B,C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Segment2D}\\left(\\operatorname{Point2D}\\left(0, y\\right), \\operatorname{Point2D}\\left(0, 0\\right)\\right)$"
      ],
      "text/plain": [
       "Segment2D(Point2D(0, y), Point2D(0, 0))"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 求垂直于BC且过点D的直线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "l_D=BC.perpendicular_line(D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Line2D}\\left(\\operatorname{Point2D}\\left(\\frac{x}{2}, \\frac{y}{2}\\right), \\operatorname{Point2D}\\left(\\frac{x}{2} + 1, \\frac{y}{2}\\right)\\right)$"
      ],
      "text/plain": [
       "Line2D(Point2D(x/2, y/2), Point2D(x/2 + 1, y/2))"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l_D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 求交点E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\operatorname{Point2D}\\left(0, \\frac{y}{2}\\right)\\right\\}$"
      ],
      "text/plain": [
       "{Point2D(0, y/2)}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Intersection(BC,l_D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 程序原因处理以集合表示的结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=list(_)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(0, \\frac{y}{2}\\right)$"
      ],
      "text/plain": [
       "Point2D(0, y/2)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 确定三角形DEC与三角形DEB全等"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 由于程序原因，对三角形sympy只判断两个三角形是否相似，所以我们利用这个函数初步写一个判断全等的函数（面积相同的两个相似三角形是全等三角形）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Triangle(sss=(1,1,1)).is_similar(Triangle(sss=(2,2,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_equal_triangle(t1,t2):\n",
    "    if(Eq(simplify(Abs(t1.area)-Abs(t2.area)),0)):\n",
    "        return t1.is_similar(t2)\n",
    "    else:\n",
    "        return false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{False}$"
      ],
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_equal_triangle(Triangle(sss=(1,1,1)),Triangle(sss=(2,2,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_equal_triangle(Triangle(sas=(x,90,y)),Triangle(sas=(y,90,x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 利用自己写的函数进行判断"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_equal_triangle(Triangle(D,E,C),Triangle(D,E,B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**因为$\\triangle{DEC}\\cong \\triangle{DEB}$,所以问题得证。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 尝试使用直角三角形外接圆进行证明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 求得三角形的外接圆"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=Triangle(A,B,C).circumcircle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Circle}\\left(\\operatorname{Point2D}\\left(\\frac{x}{2}, \\frac{y}{2}\\right), \\sqrt{\\frac{x^{2}}{4} + \\frac{y^{2}}{4}}\\right)$"
      ],
      "text/plain": [
       "Circle(Point2D(x/2, y/2), sqrt(x**2/4 + y**2/4))"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 确定点C在圆c上"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C in c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 确定点D是圆c的圆心"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eq(D,c.center)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 确定线段AB的长等于圆直径长"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eq(Segment(A,B).length,c.radius*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*结论证必*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=ln(x)/x-a*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - a x + \\frac{\\log{\\left(x \\right)}}{x}$"
      ],
      "text/plain": [
       "-a*x + log(x)/x"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Line2D}\\left(\\operatorname{Point2D}\\left(1, - a\\right), \\operatorname{Point2D}\\left(2, 1 - 2 a\\right)\\right)$"
      ],
      "text/plain": [
       "Line2D(Point2D(1, -a), Point2D(2, 1 - 2*a))"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_tangent(expr,x,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a - 2$"
      ],
      "text/plain": [
       "2*a - 2"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.equation(x,y).subs({x:2,y:-1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - x + \\frac{\\log{\\left(x \\right)}}{x}$"
      ],
      "text/plain": [
       "-x + log(x)/x"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(a,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{x^{2} + \\log{\\left(x \\right)} - 1}{x^{2}}$"
      ],
      "text/plain": [
       "-(x**2 + log(x) - 1)/x**2"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr.subs(a,1),x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7138d991be80>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(_,(x,1,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sin{\\left(\\frac{x}{3} \\right)}$"
      ],
      "text/plain": [
       "sin(x/3)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(x/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=symbols(\"t\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=t**x-x*t-(1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - t x + t^{x} + x - 1$"
      ],
      "text/plain": [
       "-t*x + t**x + x - 1"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - t + t^{x} \\log{\\left(t \\right)} + 1$"
      ],
      "text/plain": [
       "-t + t**x*log(t) + 1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(expr,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle t^{x} \\log{\\left(t \\right)}^{2}$"
      ],
      "text/plain": [
       "t**x*log(t)**2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(expr,x,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbb{R} \\cap \\left\\{\\frac{\\log{\\left(- \\frac{1 - t}{\\log{\\left(t \\right)}} \\right)}}{\\log{\\left(t \\right)}}\\right\\}$"
      ],
      "text/plain": [
       "Intersection({log(-(1 - t)/log(t))/log(t)}, Reals)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(diff(expr,x),x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Reals, {log(-(1 - t)/log(t))/log(t)})"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\log{\\left(- \\frac{1 - t}{\\log{\\left(t \\right)}} \\right)}}{\\log{\\left(t \\right)}}$"
      ],
      "text/plain": [
       "log(-(1 - t)/log(t))/log(t)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(_[1])[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\log{\\left(- \\frac{1 - t}{\\log{\\left(t \\right)}} \\right)}}{\\log{\\left(t \\right)}}$"
      ],
      "text/plain": [
       "log(-(1 - t)/log(t))/log(t)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{2}$"
      ],
      "text/plain": [
       "1/2"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "limit(answer,t,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -1 - \\frac{\\left(t - 1\\right)^{2}}{2} + t + O\\left(\\left(t - 1\\right)^{3}; t\\rightarrow 1\\right)$"
      ],
      "text/plain": [
       "-1 - (t - 1)**2/2 + t + O((t - 1)**3, (t, 1))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "series(ln(t),t,1,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "We haven't handle the type of diff(f)'s solveset type:\n<class 'sympy.sets.sets.Intersection'>\nplease wait.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_70358/2326110947.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfunction_monotonyset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpr1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/Documents/packaging_tutorial/src/function_calculator_package/extreme_points.py\u001b[0m in \u001b[0;36mfunction_monotonyset\u001b[0;34m(f, x, interval, dir)\u001b[0m\n\u001b[1;32m     60\u001b[0m         \u001b[0mx_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     61\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 62\u001b[0;31m         raise NotImplementedError(\n\u001b[0m\u001b[1;32m     63\u001b[0m             \"\\n\".join(\n\u001b[1;32m     64\u001b[0m                 [\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: We haven't handle the type of diff(f)'s solveset type:\n<class 'sympy.sets.sets.Intersection'>\nplease wait."
     ]
    }
   ],
   "source": [
    "function_monotonyset(expr1,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7fa99408fcd0>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,0.2,9),ylim=(-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x797390a07f70>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(x,exp(x)*ln(x),(x,0.02,5),ylim=(-10,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Interval in module sympy.sets.sets:\n",
      "\n",
      "class Interval(Set)\n",
      " |  Interval(start, end, left_open=False, right_open=False)\n",
      " |  \n",
      " |  Represents a real interval as a Set.\n",
      " |  \n",
      " |  Usage:\n",
      " |      Returns an interval with end points ``start`` and ``end``.\n",
      " |  \n",
      " |      For ``left_open=True`` (default ``left_open`` is ``False``) the interval\n",
      " |      will be open on the left. Similarly, for ``right_open=True`` the interval\n",
      " |      will be open on the right.\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Symbol, Interval\n",
      " |  >>> Interval(0, 1)\n",
      " |  Interval(0, 1)\n",
      " |  >>> Interval.Ropen(0, 1)\n",
      " |  Interval.Ropen(0, 1)\n",
      " |  >>> Interval.Ropen(0, 1)\n",
      " |  Interval.Ropen(0, 1)\n",
      " |  >>> Interval.Lopen(0, 1)\n",
      " |  Interval.Lopen(0, 1)\n",
      " |  >>> Interval.open(0, 1)\n",
      " |  Interval.open(0, 1)\n",
      " |  \n",
      " |  >>> a = Symbol('a', real=True)\n",
      " |  >>> Interval(0, a)\n",
      " |  Interval(0, a)\n",
      " |  \n",
      " |  Notes\n",
      " |  =====\n",
      " |  - Only real end points are supported\n",
      " |  - ``Interval(a, b)`` with $a > b$ will return the empty set\n",
      " |  - Use the ``evalf()`` method to turn an Interval into an mpmath\n",
      " |    ``mpi`` interval instance\n",
      " |  \n",
      " |  References\n",
      " |  ==========\n",
      " |  \n",
      " |  .. [1] https://en.wikipedia.org/wiki/Interval_%28mathematics%29\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Interval\n",
      " |      Set\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  as_relational(self, x)\n",
      " |      Rewrite an interval in terms of inequalities and logic operators.\n",
      " |  \n",
      " |  to_mpi(self, prec=53)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  Lopen(a, b) from sympy.core.assumptions.ManagedProperties\n",
      " |      Return an interval not including the left boundary.\n",
      " |  \n",
      " |  Ropen(a, b) from sympy.core.assumptions.ManagedProperties\n",
      " |      Return an interval not including the right boundary.\n",
      " |  \n",
      " |  open(a, b) from sympy.core.assumptions.ManagedProperties\n",
      " |      Return an interval including neither boundary.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, start, end, left_open=False, right_open=False)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  end\n",
      " |      The right end point of the interval.\n",
      " |      \n",
      " |      This property takes the same value as the ``sup`` property.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).end\n",
      " |      1\n",
      " |  \n",
      " |  is_empty\n",
      " |  \n",
      " |  is_finite_set\n",
      " |  \n",
      " |  is_left_unbounded\n",
      " |      Return ``True`` if the left endpoint is negative infinity.\n",
      " |  \n",
      " |  is_right_unbounded\n",
      " |      Return ``True`` if the right endpoint is positive infinity.\n",
      " |  \n",
      " |  left\n",
      " |  \n",
      " |  left_open\n",
      " |      True if interval is left-open.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1, left_open=True).left_open\n",
      " |      True\n",
      " |      >>> Interval(0, 1, left_open=False).left_open\n",
      " |      False\n",
      " |  \n",
      " |  right\n",
      " |  \n",
      " |  right_open\n",
      " |      True if interval is right-open.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1, right_open=True).right_open\n",
      " |      True\n",
      " |      >>> Interval(0, 1, right_open=False).right_open\n",
      " |      False\n",
      " |  \n",
      " |  start\n",
      " |      The left end point of the interval.\n",
      " |      \n",
      " |      This property takes the same value as the ``inf`` property.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).start\n",
      " |      0\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  is_Interval = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from Set:\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __contains__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |  \n",
      " |  __pow__(self, exp)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  complement(self, universe)\n",
      " |      The complement of 'self' w.r.t the given universe.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(0, 1).complement(S.Reals)\n",
      " |      Union(Interval.open(-oo, 0), Interval.open(1, oo))\n",
      " |      \n",
      " |      >>> Interval(0, 1).complement(S.UniversalSet)\n",
      " |      Complement(UniversalSet, Interval(0, 1))\n",
      " |  \n",
      " |  contains(self, other)\n",
      " |      Returns a SymPy value indicating whether ``other`` is contained\n",
      " |      in ``self``: ``true`` if it is, ``false`` if it is not, else\n",
      " |      an unevaluated ``Contains`` expression (or, as in the case of\n",
      " |      ConditionSet and a union of FiniteSet/Intervals, an expression\n",
      " |      indicating the conditions for containment).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(0.5)\n",
      " |      True\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``in`` operator, but that\n",
      " |      will raise an error unless an affirmative true or false is not\n",
      " |      obtained.\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(x)\n",
      " |      (0 <= x) & (x <= 1)\n",
      " |      >>> x in Interval(0, 1)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      TypeError: did not evaluate to a bool: None\n",
      " |      \n",
      " |      The result of 'in' is a bool, not a SymPy value\n",
      " |      \n",
      " |      >>> 1 in Interval(0, 2)\n",
      " |      True\n",
      " |      >>> _ is S.true\n",
      " |      False\n",
      " |  \n",
      " |  intersect(self, other)\n",
      " |      Returns the intersection of 'self' and 'other'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      \n",
      " |      >>> Interval(1, 3).intersect(Interval(1, 2))\n",
      " |      Interval(1, 2)\n",
      " |      \n",
      " |      >>> from sympy import imageset, Lambda, symbols, S\n",
      " |      >>> n, m = symbols('n m')\n",
      " |      >>> a = imageset(Lambda(n, 2*n), S.Integers)\n",
      " |      >>> a.intersect(imageset(Lambda(m, 2*m + 1), S.Integers))\n",
      " |      EmptySet\n",
      " |  \n",
      " |  intersection(self, other)\n",
      " |      Alias for :meth:`intersect()`\n",
      " |  \n",
      " |  is_disjoint(self, other)\n",
      " |      Returns True if ``self`` and ``other`` are disjoint.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(1, 2))\n",
      " |      False\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(3, 4))\n",
      " |      True\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Disjoint_sets\n",
      " |  \n",
      " |  is_proper_subset(self, other)\n",
      " |      Returns True if ``self`` is a proper subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_proper_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_subset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_proper_superset(self, other)\n",
      " |      Returns True if ``self`` is a proper superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 0.5))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_subset(self, other)\n",
      " |      Returns True if ``self`` is a subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_subset(Interval(0, 1, left_open=True))\n",
      " |      False\n",
      " |  \n",
      " |  is_superset(self, other)\n",
      " |      Returns True if ``self`` is a superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_superset(Interval(0, 1))\n",
      " |      False\n",
      " |      >>> Interval(0, 1).is_superset(Interval(0, 1, left_open=True))\n",
      " |      True\n",
      " |  \n",
      " |  isdisjoint(self, other)\n",
      " |      Alias for :meth:`is_disjoint()`\n",
      " |  \n",
      " |  issubset(self, other)\n",
      " |      Alias for :meth:`is_subset()`\n",
      " |  \n",
      " |  issuperset(self, other)\n",
      " |      Alias for :meth:`is_superset()`\n",
      " |  \n",
      " |  powerset(self)\n",
      " |      Find the Power set of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import EmptySet, FiniteSet, Interval\n",
      " |      \n",
      " |      A power set of an empty set:\n",
      " |      \n",
      " |      >>> A = EmptySet\n",
      " |      >>> A.powerset()\n",
      " |      {EmptySet}\n",
      " |      \n",
      " |      A power set of a finite set:\n",
      " |      \n",
      " |      >>> A = FiniteSet(1, 2)\n",
      " |      >>> a, b, c = FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)\n",
      " |      >>> A.powerset() == FiniteSet(a, b, c, EmptySet)\n",
      " |      True\n",
      " |      \n",
      " |      A power set of an interval:\n",
      " |      \n",
      " |      >>> Interval(1, 2).powerset()\n",
      " |      PowerSet(Interval(1, 2))\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Power_set\n",
      " |  \n",
      " |  symmetric_difference(self, other)\n",
      " |      Returns symmetric difference of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(1, 3).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(3, oo))\n",
      " |      >>> Interval(1, 10).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(10, oo))\n",
      " |      \n",
      " |      >>> from sympy import S, EmptySet\n",
      " |      >>> S.Reals.symmetric_difference(EmptySet)\n",
      " |      Reals\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      .. [1] https://en.wikipedia.org/wiki/Symmetric_difference\n",
      " |  \n",
      " |  union(self, other)\n",
      " |      Returns the union of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``+`` operator:\n",
      " |      \n",
      " |      >>> from sympy import Interval, FiniteSet\n",
      " |      >>> Interval(0, 1).union(Interval(2, 3))\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(0, 1) + Interval(2, 3)\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(1, 2, True, True) + FiniteSet(2, 3)\n",
      " |      Union({3}, Interval.Lopen(1, 2))\n",
      " |      \n",
      " |      Similarly it is possible to use the ``-`` operator for set differences:\n",
      " |      \n",
      " |      >>> Interval(0, 2) - Interval(0, 1)\n",
      " |      Interval.Lopen(1, 2)\n",
      " |      >>> Interval(1, 3) - FiniteSet(2)\n",
      " |      Union(Interval.Ropen(1, 2), Interval.Lopen(2, 3))\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from Set:\n",
      " |  \n",
      " |  boundary\n",
      " |      The boundary or frontier of a set.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A point x is on the boundary of a set S if\n",
      " |      \n",
      " |      1.  x is in the closure of S.\n",
      " |          I.e. Every neighborhood of x contains a point in S.\n",
      " |      2.  x is not in the interior of S.\n",
      " |          I.e. There does not exist an open set centered on x contained\n",
      " |          entirely within S.\n",
      " |      \n",
      " |      There are the points on the outer rim of S.  If S is open then these\n",
      " |      points need not actually be contained within S.\n",
      " |      \n",
      " |      For example, the boundary of an interval is its start and end points.\n",
      " |      This is true regardless of whether or not the interval is open.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).boundary\n",
      " |      {0, 1}\n",
      " |      >>> Interval(0, 1, True, False).boundary\n",
      " |      {0, 1}\n",
      " |  \n",
      " |  closure\n",
      " |      Property method which returns the closure of a set.\n",
      " |      The closure is defined as the union of the set itself and its\n",
      " |      boundary.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S, Interval\n",
      " |      >>> S.Reals.closure\n",
      " |      Reals\n",
      " |      >>> Interval(0, 1).closure\n",
      " |      Interval(0, 1)\n",
      " |  \n",
      " |  inf\n",
      " |      The infimum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).inf\n",
      " |      0\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).inf\n",
      " |      0\n",
      " |  \n",
      " |  interior\n",
      " |      Property method which returns the interior of a set.\n",
      " |      The interior of a set S consists all points of S that do not\n",
      " |      belong to the boundary of S.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).interior\n",
      " |      Interval.open(0, 1)\n",
      " |      >>> Interval(0, 1).boundary.interior\n",
      " |      EmptySet\n",
      " |  \n",
      " |  is_EmptySet\n",
      " |  \n",
      " |  is_closed\n",
      " |      A property method to check whether a set is closed.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is closed if its complement is an open set. The closedness of a\n",
      " |      subset of the reals is determined with respect to R and its standard\n",
      " |      topology.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_closed\n",
      " |      True\n",
      " |  \n",
      " |  is_open\n",
      " |      Property method to check whether a set is open.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is open if and only if it has an empty intersection with its\n",
      " |      boundary. In particular, a subset A of the reals is open if and only\n",
      " |      if each one of its points is contained in an open interval that is a\n",
      " |      subset of A.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S\n",
      " |      >>> S.Reals.is_open\n",
      " |      True\n",
      " |      >>> S.Rationals.is_open\n",
      " |      False\n",
      " |  \n",
      " |  kind\n",
      " |      The kind of a Set\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      Any :class:`Set` will have kind :class:`SetKind` which is\n",
      " |      parametrised by the kind of the elements of the set. For example\n",
      " |      most sets are sets of numbers and will have kind\n",
      " |      ``SetKind(NumberKind)``. If elements of sets are different in kind than\n",
      " |      their kind will ``SetKind(UndefinedKind)``. See\n",
      " |      :class:`sympy.core.kind.Kind` for an explanation of the kind system.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Matrix, FiniteSet, EmptySet, ProductSet, PowerSet\n",
      " |      \n",
      " |      >>> FiniteSet(Matrix([1, 2])).kind\n",
      " |      SetKind(MatrixKind(NumberKind))\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind\n",
      " |      SetKind(NumberKind)\n",
      " |      \n",
      " |      >>> EmptySet.kind\n",
      " |      SetKind()\n",
      " |      \n",
      " |      A :class:`sympy.sets.powerset.PowerSet` is a set of sets:\n",
      " |      \n",
      " |      >>> PowerSet({1, 2, 3}).kind\n",
      " |      SetKind(SetKind(NumberKind))\n",
      " |      \n",
      " |      A :class:`ProductSet` represents the set of tuples of elements of\n",
      " |      other sets. Its kind is :class:`sympy.core.containers.TupleKind`\n",
      " |      parametrised by the kinds of the elements of those sets:\n",
      " |      \n",
      " |      >>> p = ProductSet(FiniteSet(1, 2), FiniteSet(3, 4))\n",
      " |      >>> list(p)\n",
      " |      [(1, 3), (2, 3), (1, 4), (2, 4)]\n",
      " |      >>> p.kind\n",
      " |      SetKind(TupleKind(NumberKind, NumberKind))\n",
      " |      \n",
      " |      When all elements of the set do not have same kind, the kind\n",
      " |      will be returned as ``SetKind(UndefinedKind)``:\n",
      " |      \n",
      " |      >>> FiniteSet(0, Matrix([1, 2])).kind\n",
      " |      SetKind(UndefinedKind)\n",
      " |      \n",
      " |      The kind of the elements of a set are given by the ``element_kind``\n",
      " |      attribute of ``SetKind``:\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind.element_kind\n",
      " |      NumberKind\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      NumberKind\n",
      " |      sympy.core.kind.UndefinedKind\n",
      " |      sympy.core.containers.TupleKind\n",
      " |      MatrixKind\n",
      " |      sympy.matrices.expressions.sets.MatrixSet\n",
      " |      sympy.sets.conditionset.ConditionSet\n",
      " |      Rationals\n",
      " |      Naturals\n",
      " |      Integers\n",
      " |      sympy.sets.fancysets.ImageSet\n",
      " |      sympy.sets.fancysets.Range\n",
      " |      sympy.sets.fancysets.ComplexRegion\n",
      " |      sympy.sets.powerset.PowerSet\n",
      " |      sympy.sets.sets.ProductSet\n",
      " |      sympy.sets.sets.Interval\n",
      " |      sympy.sets.sets.Union\n",
      " |      sympy.sets.sets.Intersection\n",
      " |      sympy.sets.sets.Complement\n",
      " |      sympy.sets.sets.EmptySet\n",
      " |      sympy.sets.sets.UniversalSet\n",
      " |      sympy.sets.sets.FiniteSet\n",
      " |      sympy.sets.sets.SymmetricDifference\n",
      " |      sympy.sets.sets.DisjointUnion\n",
      " |  \n",
      " |  measure\n",
      " |      The (Lebesgue) measure of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).measure\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).measure\n",
      " |      2\n",
      " |  \n",
      " |  sup\n",
      " |      The supremum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).sup\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).sup\n",
      " |      3\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Set:\n",
      " |  \n",
      " |  is_Complement = None\n",
      " |  \n",
      " |  is_ComplexRegion = False\n",
      " |  \n",
      " |  is_FiniteSet = False\n",
      " |  \n",
      " |  is_Intersection = None\n",
      " |  \n",
      " |  is_ProductSet = False\n",
      " |  \n",
      " |  is_Union = False\n",
      " |  \n",
      " |  is_UniversalSet = None\n",
      " |  \n",
      " |  is_interval = False\n",
      " |  \n",
      " |  is_iterable = False\n",
      " |  \n",
      " |  is_number = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      A stub to allow Basic args (like Tuple) to be skipped when computing\n",
      " |      the content and primitive components of an expression.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.expr.Expr.as_content_primitive\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace(self, rule)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  class_key() from sympy.core.assumptions.ManagedProperties\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.assumptions.ManagedProperties\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __annotations__ = {'_args': 'tuple[Basic, ...]', '_mhash': 'int | None...\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Interval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function is_monotonic in module sympy.calculus.singularities:\n",
      "\n",
      "is_monotonic(expression, interval=Reals, symbol=None)\n",
      "    Return whether the function is monotonic in the given interval.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    expression : Expr\n",
      "        The target function which is being checked.\n",
      "    interval : Set, optional\n",
      "        The range of values in which we are testing (defaults to set of\n",
      "        all real numbers).\n",
      "    symbol : Symbol, optional\n",
      "        The symbol present in expression which gets varied over the given range.\n",
      "    \n",
      "    Returns\n",
      "    =======\n",
      "    \n",
      "    Boolean\n",
      "        True if ``expression`` is monotonic in the given ``interval``,\n",
      "        False otherwise.\n",
      "    \n",
      "    Raises\n",
      "    ======\n",
      "    \n",
      "    NotImplementedError\n",
      "        Monotonicity check has not been implemented for the queried function.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy import is_monotonic\n",
      "    >>> from sympy.abc import x, y\n",
      "    >>> from sympy import S, Interval, oo\n",
      "    >>> is_monotonic(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))\n",
      "    True\n",
      "    >>> is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3))\n",
      "    True\n",
      "    >>> is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo))\n",
      "    True\n",
      "    >>> is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals)\n",
      "    True\n",
      "    >>> is_monotonic(-x**2, S.Reals)\n",
      "    False\n",
      "    >>> is_monotonic(x**2 + y + 1, Interval(1, 2), x)\n",
      "    True\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(is_monotonic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function is_increasing in module sympy.calculus.singularities:\n",
      "\n",
      "is_increasing(expression, interval=Reals, symbol=None)\n",
      "    Return whether the function is increasing in the given interval.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    expression : Expr\n",
      "        The target function which is being checked.\n",
      "    interval : Set, optional\n",
      "        The range of values in which we are testing (defaults to set of\n",
      "        all real numbers).\n",
      "    symbol : Symbol, optional\n",
      "        The symbol present in expression which gets varied over the given range.\n",
      "    \n",
      "    Returns\n",
      "    =======\n",
      "    \n",
      "    Boolean\n",
      "        True if ``expression`` is increasing (either strictly increasing or\n",
      "        constant) in the given ``interval``, False otherwise.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy import is_increasing\n",
      "    >>> from sympy.abc import x, y\n",
      "    >>> from sympy import S, Interval, oo\n",
      "    >>> is_increasing(x**3 - 3*x**2 + 4*x, S.Reals)\n",
      "    True\n",
      "    >>> is_increasing(-x**2, Interval(-oo, 0))\n",
      "    True\n",
      "    >>> is_increasing(-x**2, Interval(0, oo))\n",
      "    False\n",
      "    >>> is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3))\n",
      "    False\n",
      "    >>> is_increasing(x**2 + y, Interval(1, 2), x)\n",
      "    True\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(is_increasing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Union' object has no attribute 'left_open'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_78054/1478102238.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfunction_monotonyset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mReals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/Documents/packaging_tutorial/src/function_calculator_package/extreme_points.py\u001b[0m in \u001b[0;36mfunction_monotonyset\u001b[0;34m(f, x, interval, dir)\u001b[0m\n\u001b[1;32m     31\u001b[0m         \u001b[0minterval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcontinuous_domain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mReals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     32\u001b[0m     \u001b[0;31m# we should first check the interval's edge.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 33\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0minterval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mleft_open\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     34\u001b[0m         \u001b[0minterval_inf_value\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlimit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minterval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"+\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     35\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Union' object has no attribute 'left_open'"
     ]
    }
   ],
   "source": [
    "function_monotonyset(1/x,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, 0\\right) \\cup \\left(0, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(-oo, 0), Interval.open(0, oo))"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "continuous_domain(1/x,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(answer,Union)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__and__',\n",
       " '__annotations__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getnewargs__',\n",
       " '__getstate__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__or__',\n",
       " '__pow__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__setstate__',\n",
       " '__sizeof__',\n",
       " '__slots__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__sympy__',\n",
       " '__weakref__',\n",
       " '__xor__',\n",
       " '_args',\n",
       " '_args_type',\n",
       " '_argset',\n",
       " '_assumptions',\n",
       " '_boundary',\n",
       " '_compare_pretty',\n",
       " '_complement',\n",
       " '_constructor_postprocessor_mapping',\n",
       " '_contains',\n",
       " '_do_eq_sympify',\n",
       " '_eval_derivative_n_times',\n",
       " '_eval_evalf',\n",
       " '_eval_is_subset',\n",
       " '_eval_is_superset',\n",
       " '_eval_powerset',\n",
       " '_eval_rewrite',\n",
       " '_eval_subs',\n",
       " '_evalf',\n",
       " '_exec_constructor_postprocessors',\n",
       " '_explicit_class_assumptions',\n",
       " '_from_args',\n",
       " '_has',\n",
       " '_has_matcher',\n",
       " '_hashable_content',\n",
       " '_inf',\n",
       " '_infimum_key',\n",
       " '_kind',\n",
       " '_matches_commutative',\n",
       " '_measure',\n",
       " '_mhash',\n",
       " '_new_args_filter',\n",
       " '_new_rawargs',\n",
       " '_prop_handler',\n",
       " '_recursive_call',\n",
       " '_repr_disabled',\n",
       " '_repr_latex_',\n",
       " '_repr_png_',\n",
       " '_repr_svg_',\n",
       " '_rewrite',\n",
       " '_sage_',\n",
       " '_sorted_args',\n",
       " '_subs',\n",
       " '_sup',\n",
       " '_symmetric_difference',\n",
       " '_to_mpmath',\n",
       " '_xreplace',\n",
       " 'args',\n",
       " 'as_content_primitive',\n",
       " 'as_dummy',\n",
       " 'as_relational',\n",
       " 'assumptions0',\n",
       " 'atoms',\n",
       " 'boundary',\n",
       " 'canonical_variables',\n",
       " 'class_key',\n",
       " 'closure',\n",
       " 'compare',\n",
       " 'complement',\n",
       " 'contains',\n",
       " 'copy',\n",
       " 'could_extract_minus_sign',\n",
       " 'count',\n",
       " 'count_ops',\n",
       " 'default_assumptions',\n",
       " 'doit',\n",
       " 'dummy_eq',\n",
       " 'evalf',\n",
       " 'expr_free_symbols',\n",
       " 'find',\n",
       " 'flatten',\n",
       " 'free_symbols',\n",
       " 'fromiter',\n",
       " 'func',\n",
       " 'has',\n",
       " 'has_free',\n",
       " 'identity',\n",
       " 'inf',\n",
       " 'interior',\n",
       " 'intersect',\n",
       " 'intersection',\n",
       " 'is_Add',\n",
       " 'is_AlgebraicNumber',\n",
       " 'is_Atom',\n",
       " 'is_Boolean',\n",
       " 'is_Complement',\n",
       " 'is_ComplexRegion',\n",
       " 'is_Derivative',\n",
       " 'is_Dummy',\n",
       " 'is_EmptySet',\n",
       " 'is_Equality',\n",
       " 'is_FiniteSet',\n",
       " 'is_Float',\n",
       " 'is_Function',\n",
       " 'is_Indexed',\n",
       " 'is_Integer',\n",
       " 'is_Intersection',\n",
       " 'is_Interval',\n",
       " 'is_MatAdd',\n",
       " 'is_MatMul',\n",
       " 'is_Matrix',\n",
       " 'is_Mul',\n",
       " 'is_Not',\n",
       " 'is_Number',\n",
       " 'is_NumberSymbol',\n",
       " 'is_Order',\n",
       " 'is_Piecewise',\n",
       " 'is_Point',\n",
       " 'is_Poly',\n",
       " 'is_Pow',\n",
       " 'is_ProductSet',\n",
       " 'is_Rational',\n",
       " 'is_Relational',\n",
       " 'is_Symbol',\n",
       " 'is_Union',\n",
       " 'is_UniversalSet',\n",
       " 'is_Vector',\n",
       " 'is_Wild',\n",
       " 'is_algebraic',\n",
       " 'is_antihermitian',\n",
       " 'is_closed',\n",
       " 'is_commutative',\n",
       " 'is_comparable',\n",
       " 'is_complex',\n",
       " 'is_composite',\n",
       " 'is_disjoint',\n",
       " 'is_empty',\n",
       " 'is_even',\n",
       " 'is_extended_negative',\n",
       " 'is_extended_nonnegative',\n",
       " 'is_extended_nonpositive',\n",
       " 'is_extended_nonzero',\n",
       " 'is_extended_positive',\n",
       " 'is_extended_real',\n",
       " 'is_finite',\n",
       " 'is_finite_set',\n",
       " 'is_hermitian',\n",
       " 'is_hypergeometric',\n",
       " 'is_imaginary',\n",
       " 'is_infinite',\n",
       " 'is_integer',\n",
       " 'is_interval',\n",
       " 'is_irrational',\n",
       " 'is_iterable',\n",
       " 'is_negative',\n",
       " 'is_noninteger',\n",
       " 'is_nonnegative',\n",
       " 'is_nonpositive',\n",
       " 'is_nonzero',\n",
       " 'is_number',\n",
       " 'is_odd',\n",
       " 'is_open',\n",
       " 'is_polar',\n",
       " 'is_positive',\n",
       " 'is_prime',\n",
       " 'is_proper_subset',\n",
       " 'is_proper_superset',\n",
       " 'is_rational',\n",
       " 'is_real',\n",
       " 'is_subset',\n",
       " 'is_superset',\n",
       " 'is_symbol',\n",
       " 'is_transcendental',\n",
       " 'is_zero',\n",
       " 'isdisjoint',\n",
       " 'issubset',\n",
       " 'issuperset',\n",
       " 'kind',\n",
       " 'make_args',\n",
       " 'match',\n",
       " 'matches',\n",
       " 'measure',\n",
       " 'n',\n",
       " 'powerset',\n",
       " 'rcall',\n",
       " 'refine',\n",
       " 'replace',\n",
       " 'rewrite',\n",
       " 'simplify',\n",
       " 'sort_key',\n",
       " 'subs',\n",
       " 'sup',\n",
       " 'symmetric_difference',\n",
       " 'union',\n",
       " 'xreplace',\n",
       " 'zero']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer.is_Union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(answer.args[0]).is_interval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Interval(0,4).is_N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\sqrt{5}, \\sqrt{5}\\right\\}$"
      ],
      "text/plain": [
       "{-sqrt(5), sqrt(5)}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(5-x**2,x,answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-20, -19, \\ldots, 20\\right\\} \\cup \\left\\{- \\frac{39}{2}, - \\frac{37}{2}, - \\frac{35}{2}, - \\frac{33}{2}, - \\frac{31}{2}, - \\frac{29}{2}, - \\frac{27}{2}, - \\frac{25}{2}, - \\frac{23}{2}, - \\frac{21}{2}, - \\frac{19}{2}, - \\frac{17}{2}, - \\frac{15}{2}, - \\frac{13}{2}, - \\frac{11}{2}, - \\frac{9}{2}, - \\frac{7}{2}, - \\frac{5}{2}, - \\frac{3}{2}, - \\frac{1}{2}, \\frac{1}{2}, \\frac{3}{2}, \\frac{5}{2}, \\frac{7}{2}, \\frac{9}{2}, \\frac{11}{2}, \\frac{13}{2}, \\frac{15}{2}, \\frac{17}{2}, \\frac{19}{2}, \\frac{21}{2}, \\frac{23}{2}, \\frac{25}{2}, \\frac{27}{2}, \\frac{29}{2}, \\frac{31}{2}, \\frac{33}{2}, \\frac{35}{2}, \\frac{37}{2}, \\frac{39}{2}\\right\\}$"
      ],
      "text/plain": [
       "Union({-39/2, -37/2, -35/2, -33/2, -31/2, -29/2, -27/2, -25/2, -23/2, -21/2, -19/2, -17/2, -15/2, -13/2, -11/2, -9/2, -7/2, -5/2, -3/2, -1/2, 1/2, 3/2, 5/2, 7/2, 9/2, 11/2, 13/2, 15/2, 17/2, 19/2, 21/2, 23/2, 25/2, 27/2, 29/2, 31/2, 33/2, 35/2, 37/2, 39/2}, Range(-20, 21, 1))"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(sin(2*pi*x),x,Interval(-20,20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbb{Z} \\cup \\left\\{n + \\frac{1}{2}\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\}$"
      ],
      "text/plain": [
       "Union(ImageSet(Lambda(_n, _n + 1/2), Integers), Integers)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\sqrt{3} \\pi}{3}$"
      ],
      "text/plain": [
       "2*sqrt(3)*pi/3"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(x*sqrt(3)).period()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{n + \\frac{1}{2}\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\}$"
      ],
      "text/plain": [
       "ImageSet(Lambda(_n, _n + 1/2), Integers)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.args[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.sets.fancysets.ImageSet"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on ImageSet in module sympy.sets.fancysets object:\n",
      "\n",
      "class ImageSet(sympy.sets.sets.Set)\n",
      " |  ImageSet(flambda, *sets)\n",
      " |  \n",
      " |  Image of a set under a mathematical function. The transformation\n",
      " |  must be given as a Lambda function which has as many arguments\n",
      " |  as the elements of the set upon which it operates, e.g. 1 argument\n",
      " |  when acting on the set of integers or 2 arguments when acting on\n",
      " |  a complex region.\n",
      " |  \n",
      " |  This function is not normally called directly, but is called\n",
      " |  from ``imageset``.\n",
      " |  \n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Symbol, S, pi, Dummy, Lambda\n",
      " |  >>> from sympy import FiniteSet, ImageSet, Interval\n",
      " |  \n",
      " |  >>> x = Symbol('x')\n",
      " |  >>> N = S.Naturals\n",
      " |  >>> squares = ImageSet(Lambda(x, x**2), N) # {x**2 for x in N}\n",
      " |  >>> 4 in squares\n",
      " |  True\n",
      " |  >>> 5 in squares\n",
      " |  False\n",
      " |  \n",
      " |  >>> FiniteSet(0, 1, 2, 3, 4, 5, 6, 7, 9, 10).intersect(squares)\n",
      " |  {1, 4, 9}\n",
      " |  \n",
      " |  >>> square_iterable = iter(squares)\n",
      " |  >>> for i in range(4):\n",
      " |  ...     next(square_iterable)\n",
      " |  1\n",
      " |  4\n",
      " |  9\n",
      " |  16\n",
      " |  \n",
      " |  If you want to get value for `x` = 2, 1/2 etc. (Please check whether the\n",
      " |  `x` value is in ``base_set`` or not before passing it as args)\n",
      " |  \n",
      " |  >>> squares.lamda(2)\n",
      " |  4\n",
      " |  >>> squares.lamda(S(1)/2)\n",
      " |  1/4\n",
      " |  \n",
      " |  >>> n = Dummy('n')\n",
      " |  >>> solutions = ImageSet(Lambda(n, n*pi), S.Integers) # solutions of sin(x) = 0\n",
      " |  >>> dom = Interval(-1, 1)\n",
      " |  >>> dom.intersect(solutions)\n",
      " |  {0}\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  \n",
      " |  sympy.sets.sets.imageset\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      ImageSet\n",
      " |      sympy.sets.sets.Set\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __iter__(self)\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, flambda, *sets)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  base_pset\n",
      " |  \n",
      " |  base_set\n",
      " |  \n",
      " |  base_sets\n",
      " |  \n",
      " |  is_iterable\n",
      " |  \n",
      " |  lamda\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __contains__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |  \n",
      " |  __pow__(self, exp)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  complement(self, universe)\n",
      " |      The complement of 'self' w.r.t the given universe.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(0, 1).complement(S.Reals)\n",
      " |      Union(Interval.open(-oo, 0), Interval.open(1, oo))\n",
      " |      \n",
      " |      >>> Interval(0, 1).complement(S.UniversalSet)\n",
      " |      Complement(UniversalSet, Interval(0, 1))\n",
      " |  \n",
      " |  contains(self, other)\n",
      " |      Returns a SymPy value indicating whether ``other`` is contained\n",
      " |      in ``self``: ``true`` if it is, ``false`` if it is not, else\n",
      " |      an unevaluated ``Contains`` expression (or, as in the case of\n",
      " |      ConditionSet and a union of FiniteSet/Intervals, an expression\n",
      " |      indicating the conditions for containment).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(0.5)\n",
      " |      True\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``in`` operator, but that\n",
      " |      will raise an error unless an affirmative true or false is not\n",
      " |      obtained.\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(x)\n",
      " |      (0 <= x) & (x <= 1)\n",
      " |      >>> x in Interval(0, 1)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      TypeError: did not evaluate to a bool: None\n",
      " |      \n",
      " |      The result of 'in' is a bool, not a SymPy value\n",
      " |      \n",
      " |      >>> 1 in Interval(0, 2)\n",
      " |      True\n",
      " |      >>> _ is S.true\n",
      " |      False\n",
      " |  \n",
      " |  intersect(self, other)\n",
      " |      Returns the intersection of 'self' and 'other'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      \n",
      " |      >>> Interval(1, 3).intersect(Interval(1, 2))\n",
      " |      Interval(1, 2)\n",
      " |      \n",
      " |      >>> from sympy import imageset, Lambda, symbols, S\n",
      " |      >>> n, m = symbols('n m')\n",
      " |      >>> a = imageset(Lambda(n, 2*n), S.Integers)\n",
      " |      >>> a.intersect(imageset(Lambda(m, 2*m + 1), S.Integers))\n",
      " |      EmptySet\n",
      " |  \n",
      " |  intersection(self, other)\n",
      " |      Alias for :meth:`intersect()`\n",
      " |  \n",
      " |  is_disjoint(self, other)\n",
      " |      Returns True if ``self`` and ``other`` are disjoint.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(1, 2))\n",
      " |      False\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(3, 4))\n",
      " |      True\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Disjoint_sets\n",
      " |  \n",
      " |  is_proper_subset(self, other)\n",
      " |      Returns True if ``self`` is a proper subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_proper_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_subset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_proper_superset(self, other)\n",
      " |      Returns True if ``self`` is a proper superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 0.5))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_subset(self, other)\n",
      " |      Returns True if ``self`` is a subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_subset(Interval(0, 1, left_open=True))\n",
      " |      False\n",
      " |  \n",
      " |  is_superset(self, other)\n",
      " |      Returns True if ``self`` is a superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_superset(Interval(0, 1))\n",
      " |      False\n",
      " |      >>> Interval(0, 1).is_superset(Interval(0, 1, left_open=True))\n",
      " |      True\n",
      " |  \n",
      " |  isdisjoint(self, other)\n",
      " |      Alias for :meth:`is_disjoint()`\n",
      " |  \n",
      " |  issubset(self, other)\n",
      " |      Alias for :meth:`is_subset()`\n",
      " |  \n",
      " |  issuperset(self, other)\n",
      " |      Alias for :meth:`is_superset()`\n",
      " |  \n",
      " |  powerset(self)\n",
      " |      Find the Power set of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import EmptySet, FiniteSet, Interval\n",
      " |      \n",
      " |      A power set of an empty set:\n",
      " |      \n",
      " |      >>> A = EmptySet\n",
      " |      >>> A.powerset()\n",
      " |      {EmptySet}\n",
      " |      \n",
      " |      A power set of a finite set:\n",
      " |      \n",
      " |      >>> A = FiniteSet(1, 2)\n",
      " |      >>> a, b, c = FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)\n",
      " |      >>> A.powerset() == FiniteSet(a, b, c, EmptySet)\n",
      " |      True\n",
      " |      \n",
      " |      A power set of an interval:\n",
      " |      \n",
      " |      >>> Interval(1, 2).powerset()\n",
      " |      PowerSet(Interval(1, 2))\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Power_set\n",
      " |  \n",
      " |  symmetric_difference(self, other)\n",
      " |      Returns symmetric difference of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(1, 3).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(3, oo))\n",
      " |      >>> Interval(1, 10).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(10, oo))\n",
      " |      \n",
      " |      >>> from sympy import S, EmptySet\n",
      " |      >>> S.Reals.symmetric_difference(EmptySet)\n",
      " |      Reals\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      .. [1] https://en.wikipedia.org/wiki/Symmetric_difference\n",
      " |  \n",
      " |  union(self, other)\n",
      " |      Returns the union of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``+`` operator:\n",
      " |      \n",
      " |      >>> from sympy import Interval, FiniteSet\n",
      " |      >>> Interval(0, 1).union(Interval(2, 3))\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(0, 1) + Interval(2, 3)\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(1, 2, True, True) + FiniteSet(2, 3)\n",
      " |      Union({3}, Interval.Lopen(1, 2))\n",
      " |      \n",
      " |      Similarly it is possible to use the ``-`` operator for set differences:\n",
      " |      \n",
      " |      >>> Interval(0, 2) - Interval(0, 1)\n",
      " |      Interval.Lopen(1, 2)\n",
      " |      >>> Interval(1, 3) - FiniteSet(2)\n",
      " |      Union(Interval.Ropen(1, 2), Interval.Lopen(2, 3))\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  boundary\n",
      " |      The boundary or frontier of a set.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A point x is on the boundary of a set S if\n",
      " |      \n",
      " |      1.  x is in the closure of S.\n",
      " |          I.e. Every neighborhood of x contains a point in S.\n",
      " |      2.  x is not in the interior of S.\n",
      " |          I.e. There does not exist an open set centered on x contained\n",
      " |          entirely within S.\n",
      " |      \n",
      " |      There are the points on the outer rim of S.  If S is open then these\n",
      " |      points need not actually be contained within S.\n",
      " |      \n",
      " |      For example, the boundary of an interval is its start and end points.\n",
      " |      This is true regardless of whether or not the interval is open.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).boundary\n",
      " |      {0, 1}\n",
      " |      >>> Interval(0, 1, True, False).boundary\n",
      " |      {0, 1}\n",
      " |  \n",
      " |  closure\n",
      " |      Property method which returns the closure of a set.\n",
      " |      The closure is defined as the union of the set itself and its\n",
      " |      boundary.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S, Interval\n",
      " |      >>> S.Reals.closure\n",
      " |      Reals\n",
      " |      >>> Interval(0, 1).closure\n",
      " |      Interval(0, 1)\n",
      " |  \n",
      " |  inf\n",
      " |      The infimum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).inf\n",
      " |      0\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).inf\n",
      " |      0\n",
      " |  \n",
      " |  interior\n",
      " |      Property method which returns the interior of a set.\n",
      " |      The interior of a set S consists all points of S that do not\n",
      " |      belong to the boundary of S.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).interior\n",
      " |      Interval.open(0, 1)\n",
      " |      >>> Interval(0, 1).boundary.interior\n",
      " |      EmptySet\n",
      " |  \n",
      " |  is_EmptySet\n",
      " |  \n",
      " |  is_closed\n",
      " |      A property method to check whether a set is closed.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is closed if its complement is an open set. The closedness of a\n",
      " |      subset of the reals is determined with respect to R and its standard\n",
      " |      topology.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_closed\n",
      " |      True\n",
      " |  \n",
      " |  is_open\n",
      " |      Property method to check whether a set is open.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is open if and only if it has an empty intersection with its\n",
      " |      boundary. In particular, a subset A of the reals is open if and only\n",
      " |      if each one of its points is contained in an open interval that is a\n",
      " |      subset of A.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S\n",
      " |      >>> S.Reals.is_open\n",
      " |      True\n",
      " |      >>> S.Rationals.is_open\n",
      " |      False\n",
      " |  \n",
      " |  kind\n",
      " |      The kind of a Set\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      Any :class:`Set` will have kind :class:`SetKind` which is\n",
      " |      parametrised by the kind of the elements of the set. For example\n",
      " |      most sets are sets of numbers and will have kind\n",
      " |      ``SetKind(NumberKind)``. If elements of sets are different in kind than\n",
      " |      their kind will ``SetKind(UndefinedKind)``. See\n",
      " |      :class:`sympy.core.kind.Kind` for an explanation of the kind system.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Matrix, FiniteSet, EmptySet, ProductSet, PowerSet\n",
      " |      \n",
      " |      >>> FiniteSet(Matrix([1, 2])).kind\n",
      " |      SetKind(MatrixKind(NumberKind))\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind\n",
      " |      SetKind(NumberKind)\n",
      " |      \n",
      " |      >>> EmptySet.kind\n",
      " |      SetKind()\n",
      " |      \n",
      " |      A :class:`sympy.sets.powerset.PowerSet` is a set of sets:\n",
      " |      \n",
      " |      >>> PowerSet({1, 2, 3}).kind\n",
      " |      SetKind(SetKind(NumberKind))\n",
      " |      \n",
      " |      A :class:`ProductSet` represents the set of tuples of elements of\n",
      " |      other sets. Its kind is :class:`sympy.core.containers.TupleKind`\n",
      " |      parametrised by the kinds of the elements of those sets:\n",
      " |      \n",
      " |      >>> p = ProductSet(FiniteSet(1, 2), FiniteSet(3, 4))\n",
      " |      >>> list(p)\n",
      " |      [(1, 3), (2, 3), (1, 4), (2, 4)]\n",
      " |      >>> p.kind\n",
      " |      SetKind(TupleKind(NumberKind, NumberKind))\n",
      " |      \n",
      " |      When all elements of the set do not have same kind, the kind\n",
      " |      will be returned as ``SetKind(UndefinedKind)``:\n",
      " |      \n",
      " |      >>> FiniteSet(0, Matrix([1, 2])).kind\n",
      " |      SetKind(UndefinedKind)\n",
      " |      \n",
      " |      The kind of the elements of a set are given by the ``element_kind``\n",
      " |      attribute of ``SetKind``:\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind.element_kind\n",
      " |      NumberKind\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      NumberKind\n",
      " |      sympy.core.kind.UndefinedKind\n",
      " |      sympy.core.containers.TupleKind\n",
      " |      MatrixKind\n",
      " |      sympy.matrices.expressions.sets.MatrixSet\n",
      " |      sympy.sets.conditionset.ConditionSet\n",
      " |      Rationals\n",
      " |      Naturals\n",
      " |      Integers\n",
      " |      sympy.sets.fancysets.ImageSet\n",
      " |      sympy.sets.fancysets.Range\n",
      " |      sympy.sets.fancysets.ComplexRegion\n",
      " |      sympy.sets.powerset.PowerSet\n",
      " |      sympy.sets.sets.ProductSet\n",
      " |      sympy.sets.sets.Interval\n",
      " |      sympy.sets.sets.Union\n",
      " |      sympy.sets.sets.Intersection\n",
      " |      sympy.sets.sets.Complement\n",
      " |      sympy.sets.sets.EmptySet\n",
      " |      sympy.sets.sets.UniversalSet\n",
      " |      sympy.sets.sets.FiniteSet\n",
      " |      sympy.sets.sets.SymmetricDifference\n",
      " |      sympy.sets.sets.DisjointUnion\n",
      " |  \n",
      " |  measure\n",
      " |      The (Lebesgue) measure of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).measure\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).measure\n",
      " |      2\n",
      " |  \n",
      " |  sup\n",
      " |      The supremum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).sup\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).sup\n",
      " |      3\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  is_Complement = None\n",
      " |  \n",
      " |  is_ComplexRegion = False\n",
      " |  \n",
      " |  is_FiniteSet = False\n",
      " |  \n",
      " |  is_Intersection = None\n",
      " |  \n",
      " |  is_Interval = False\n",
      " |  \n",
      " |  is_ProductSet = False\n",
      " |  \n",
      " |  is_Union = False\n",
      " |  \n",
      " |  is_UniversalSet = None\n",
      " |  \n",
      " |  is_empty = None\n",
      " |  \n",
      " |  is_finite_set = None\n",
      " |  \n",
      " |  is_interval = False\n",
      " |  \n",
      " |  is_number = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      A stub to allow Basic args (like Tuple) to be skipped when computing\n",
      " |      the content and primitive components of an expression.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.expr.Expr.as_content_primitive\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace(self, rule)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  class_key() from sympy.core.assumptions.ManagedProperties\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.assumptions.ManagedProperties\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __annotations__ = {'_args': 'tuple[Basic, ...]', '_mhash': 'int | None...\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/2\n",
      "3/2\n",
      "-1/2\n",
      "5/2\n",
      "-3/2\n",
      "7/2\n",
      "-5/2\n",
      "9/2\n",
      "-7/2\n",
      "11/2\n",
      "-9/2\n",
      "13/2\n",
      "-11/2\n",
      "15/2\n",
      "-13/2\n",
      "17/2\n",
      "-15/2\n",
      "19/2\n",
      "-17/2\n",
      "21/2\n",
      "-19/2\n",
      "23/2\n",
      "-21/2\n",
      "25/2\n",
      "-23/2\n",
      "27/2\n",
      "-25/2\n",
      "29/2\n",
      "-27/2\n",
      "31/2\n",
      "-29/2\n",
      "33/2\n",
      "-31/2\n",
      "35/2\n",
      "-33/2\n",
      "37/2\n",
      "-35/2\n",
      "39/2\n",
      "-37/2\n",
      "41/2\n"
     ]
    }
   ],
   "source": [
    "for a in answer:\n",
    "    print(a)\n",
    "    if(a>20):\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=x**2+4*y*ln(x)-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} + 4 y \\log{\\left(x \\right)} - 2$"
      ],
      "text/plain": [
       "x**2 + 4*y*log(x) - 2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 y + 2$"
      ],
      "text/plain": [
       "3*y + 2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(expr,x).subs(x,1)-y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{2}{3}\\right\\}$"
      ],
      "text/plain": [
       "{-2/3}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,y,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} - \\frac{8 \\log{\\left(x \\right)}}{3} - 2$"
      ],
      "text/plain": [
       "x**2 - 8*log(x)/3 - 2"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(y,-2/S(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{22}{3}$"
      ],
      "text/plain": [
       "22/3"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(_,x).subs(x,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 10$"
      ],
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial(5,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 60$"
      ],
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ff(5,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "224"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2024%360"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (2830747755.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[4], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m    digraph {\u001b[0m\n\u001b[0m            ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "digraph {\n",
    "A -> B\n",
    "A -> C\n",
    "B -> C\n",
    "C -> B\n",
    "B -> D\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
